06001697c8
Codex: model/list supportedReasoningEfforts per model, turn/start effort, thread reasoningEffort as the current level. Claude Code: initialize supportedEffortLevels, apply_flag_settings effortLevel at the next turn start. OpenCode v2: model variants via the session model endpoint. chat_effort sets a level; rows and chat_models carry the levels; Codex and Claude levels persist in operator_sessions.chat_effort and are re-applied before every turn.
826 lines
24 KiB
Go
826 lines
24 KiB
Go
package claude
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/opencode"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// Create records one Claude session. The CLI process starts on the first
|
|
// prompt, so creating a chat is fast and does not require a signed-in CLI yet.
|
|
func (c *Chat) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) {
|
|
directory = strings.TrimSpace(directory)
|
|
if directory == "" {
|
|
return protocol.ChatSession{}, errors.New("a directory is required")
|
|
}
|
|
if !filepath.IsAbs(directory) {
|
|
return protocol.ChatSession{}, errors.New("the chat directory must be absolute")
|
|
}
|
|
absolute, err := filepath.Abs(directory)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, err
|
|
}
|
|
if info, err := os.Stat(absolute); err != nil || !info.IsDir() {
|
|
return protocol.ChatSession{}, errors.New("the chat directory is not an existing directory")
|
|
}
|
|
id, err := newSessionID()
|
|
if err != nil {
|
|
return protocol.ChatSession{}, err
|
|
}
|
|
title = strings.TrimSpace(title)
|
|
c.SetTitle(ctx, id, title)
|
|
s := c.sessionFor(id, absolute)
|
|
s.mu.Lock()
|
|
s.title = title
|
|
s.createdAt = time.Now().UnixMilli()
|
|
s.mu.Unlock()
|
|
return protocol.ChatSession{
|
|
ID: id,
|
|
Backend: Backend,
|
|
Title: title,
|
|
ModelProvider: Backend,
|
|
Directory: absolute,
|
|
CreatedAt: s.createdAt,
|
|
UpdatedAt: s.createdAt,
|
|
Tag: protocol.ChatSessionTagOperator,
|
|
}, nil
|
|
}
|
|
|
|
// Session resolves one session from memory or from its retained transcript, so
|
|
// a registry row survives a server restart.
|
|
func (c *Chat) Session(ctx context.Context, id string) (protocol.ChatSession, bool, error) {
|
|
if s := c.session(id); s != nil {
|
|
s.mu.Lock()
|
|
session := s.chatSessionLocked()
|
|
s.mu.Unlock()
|
|
return session, true, nil
|
|
}
|
|
meta, ok := transcriptSession(id)
|
|
if !ok {
|
|
return protocol.ChatSession{}, false, nil
|
|
}
|
|
return meta, true, nil
|
|
}
|
|
|
|
// Sessions lists sessions this process has opened. Registry rows for sessions
|
|
// from an earlier server are resolved by the manager through Session.
|
|
func (c *Chat) Sessions(ctx context.Context) ([]protocol.ChatSession, error) {
|
|
c.mu.Lock()
|
|
states := make([]*session, 0, len(c.sessions))
|
|
for _, s := range c.sessions {
|
|
states = append(states, s)
|
|
}
|
|
c.mu.Unlock()
|
|
sessions := make([]protocol.ChatSession, 0, len(states))
|
|
for _, s := range states {
|
|
s.mu.Lock()
|
|
sessions = append(sessions, s.chatSessionLocked())
|
|
s.mu.Unlock()
|
|
}
|
|
sort.Slice(sessions, func(i, j int) bool { return sessions[i].ID < sessions[j].ID })
|
|
return sessions, nil
|
|
}
|
|
|
|
func (s *session) chatSessionLocked() protocol.ChatSession {
|
|
model := s.modelActual
|
|
if model == "" {
|
|
model = s.model
|
|
}
|
|
return protocol.ChatSession{
|
|
ID: s.id,
|
|
Backend: Backend,
|
|
Title: s.title,
|
|
Model: model,
|
|
ModelProvider: Backend,
|
|
Directory: s.directory,
|
|
CreatedAt: s.createdAt,
|
|
UpdatedAt: s.lastUsed.UnixMilli(),
|
|
}
|
|
}
|
|
|
|
// Prompt starts one turn with the default model selection.
|
|
func (c *Chat) Prompt(ctx context.Context, id, text string) error {
|
|
return c.PromptWithMessageID(ctx, id, text, "")
|
|
}
|
|
|
|
func (c *Chat) PromptWithMessageID(ctx context.Context, id, text, messageID string) error {
|
|
return c.PromptWithMessageIDModelFiles(ctx, id, text, messageID, "", nil)
|
|
}
|
|
|
|
func (c *Chat) PromptWithMessageIDModel(ctx context.Context, id, text, messageID, model string) error {
|
|
return c.PromptWithMessageIDModelFiles(ctx, id, text, messageID, model, nil)
|
|
}
|
|
|
|
func (c *Chat) PromptWithMessageIDFiles(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) error {
|
|
return c.PromptWithMessageIDModelFiles(ctx, id, text, messageID, "", files)
|
|
}
|
|
|
|
// PromptWithMessageIDModelFiles submits one user turn, optionally applying the
|
|
// saved next-turn model and the server's private attachment files.
|
|
func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, messageID, model string, files []opencode.PromptFile) error {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
found := false
|
|
if meta, ok := transcriptSession(id); ok {
|
|
s = c.sessionFor(id, meta.Directory)
|
|
found = true
|
|
}
|
|
if !found {
|
|
return errors.New("unknown Claude session " + id)
|
|
}
|
|
}
|
|
s.mu.Lock()
|
|
if strings.TrimSpace(text) == "" {
|
|
s.mu.Unlock()
|
|
return errors.New("a nonempty chat prompt is required")
|
|
}
|
|
if model != "" {
|
|
s.model = model
|
|
}
|
|
directory := s.directory
|
|
s.lastUsed = time.Now()
|
|
s.mu.Unlock()
|
|
if directory == "" {
|
|
return errors.New("the Claude session has no working directory")
|
|
}
|
|
s.promptMu.Lock()
|
|
defer s.promptMu.Unlock()
|
|
proc, err := s.ensureProcess(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Apply a selection that the running process has not seen yet.
|
|
s.mu.Lock()
|
|
requested := s.model
|
|
applied := s.appliedModel
|
|
s.mu.Unlock()
|
|
if requested != "" && requested != applied {
|
|
setCtx, cancel := context.WithTimeout(ctx, controlRequestTimeout)
|
|
_, err := proc.request(setCtx, "set_model", map[string]any{"model": requested})
|
|
cancel()
|
|
if err != nil {
|
|
return fmt.Errorf("switch Claude model: %w", err)
|
|
}
|
|
s.mu.Lock()
|
|
s.appliedModel = requested
|
|
s.mu.Unlock()
|
|
}
|
|
if err := s.applyMode(ctx, proc); err != nil {
|
|
return err
|
|
}
|
|
if err := s.applyEffort(ctx, proc); err != nil {
|
|
return err
|
|
}
|
|
content, err := promptContent(text, files)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
turn := fmt.Sprintf("claude-%d", time.Now().UnixNano())
|
|
s.mu.Lock()
|
|
s.turnID = turn
|
|
s.running = true
|
|
s.steered = 0
|
|
s.awaitFollowUp = false
|
|
s.recordPromptLocked(messageID, text)
|
|
notices := s.envNotices
|
|
s.envNotices = nil
|
|
s.mu.Unlock()
|
|
s.emit(protocol.ChatEventFrame{SessionID: id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepStarted, TurnID: turn}})
|
|
for index, notice := range notices {
|
|
s.emitEnvNotice(turn, index, notice)
|
|
}
|
|
payload := map[string]any{
|
|
"type": "user",
|
|
"message": map[string]any{"role": "user", "content": content},
|
|
}
|
|
if err := proc.write(payload); err != nil {
|
|
s.finishTurn(turn, "Claude Code is not accepting input: "+err.Error())
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *session) recordPromptLocked(messageID, text string) {
|
|
s.prompts = append(s.prompts, promptRecord{id: messageID, text: strings.TrimSpace(text)})
|
|
if len(s.prompts) > 200 {
|
|
s.prompts = s.prompts[len(s.prompts)-200:]
|
|
}
|
|
}
|
|
|
|
// SteerPrompt hands a user message to the turn Claude Code is running now. The
|
|
// stream-json CLI accepts user messages on stdin while it works and reads them
|
|
// at its next step, surfacing them to the model within the running turn (or,
|
|
// when the turn ends first, as its own follow-up turn). It reports false when
|
|
// the session has no live process with a turn in flight, so the caller queues
|
|
// the prompt instead. The model/mode selection applies at the next turn.
|
|
func (c *Chat) SteerPrompt(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) (bool, error) {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return false, nil
|
|
}
|
|
if strings.TrimSpace(text) == "" {
|
|
return false, errors.New("a nonempty chat prompt is required")
|
|
}
|
|
s.promptMu.Lock()
|
|
defer s.promptMu.Unlock()
|
|
s.mu.Lock()
|
|
proc := s.proc
|
|
running := s.running
|
|
s.mu.Unlock()
|
|
if proc == nil || !running {
|
|
return false, nil
|
|
}
|
|
content, err := promptContent(text, files)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
payload := map[string]any{
|
|
"type": "user",
|
|
"message": map[string]any{"role": "user", "content": content},
|
|
}
|
|
if err := proc.write(payload); err != nil {
|
|
return false, fmt.Errorf("Claude Code is not accepting input: %w", err)
|
|
}
|
|
s.mu.Lock()
|
|
s.steered++
|
|
s.lastUsed = time.Now()
|
|
s.recordPromptLocked(messageID, text)
|
|
s.mu.Unlock()
|
|
return true, nil
|
|
}
|
|
|
|
// adoptFollowUpTurn starts a turn for output the CLI produces after a result
|
|
// while messages written mid-turn were outstanding: the CLI is running them as
|
|
// a turn of its own, which clients must see as running until its result.
|
|
func (s *session) adoptFollowUpTurn() {
|
|
s.mu.Lock()
|
|
if s.running || !s.awaitFollowUp {
|
|
s.mu.Unlock()
|
|
return
|
|
}
|
|
s.awaitFollowUp = false
|
|
turn := fmt.Sprintf("claude-%d", time.Now().UnixNano())
|
|
s.turnID = turn
|
|
s.running = true
|
|
s.mu.Unlock()
|
|
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepStarted, TurnID: turn}})
|
|
}
|
|
|
|
// emitEnvNotice shows a directory-environment warning (for example a blocked
|
|
// .envrc) in the turn, so the operator sees why the directory's account or
|
|
// tools were not applied.
|
|
func (s *session) emitEnvNotice(turn string, index int, notice string) {
|
|
id := fmt.Sprintf("claude-env-%s-%d", turn, index)
|
|
s.emit(protocol.ChatEventFrame{
|
|
SessionID: s.id,
|
|
NativeTurnID: turn,
|
|
MessageID: id,
|
|
Kind: protocol.ChatEventTool,
|
|
Part: &protocol.ChatPart{
|
|
Type: protocol.ChatPartTool,
|
|
ID: id,
|
|
Name: "Directory environment",
|
|
State: &protocol.ChatToolState{Status: protocol.ChatToolError, Error: &protocol.ChatError{Type: "environment", Message: boundedText(notice, 2<<10)}},
|
|
},
|
|
})
|
|
}
|
|
|
|
// finishTurn settles a turn that never reached a CLI result.
|
|
func (s *session) finishTurn(turn, diagnostic string) {
|
|
s.mu.Lock()
|
|
if s.turnID != turn {
|
|
s.mu.Unlock()
|
|
return
|
|
}
|
|
s.running = false
|
|
s.turnID = ""
|
|
s.mu.Unlock()
|
|
if diagnostic != "" {
|
|
s.emit(protocol.ChatEventFrame{
|
|
SessionID: s.id,
|
|
NativeTurnID: turn,
|
|
MessageID: "claude-error-" + turn,
|
|
Kind: protocol.ChatEventTool,
|
|
Part: &protocol.ChatPart{
|
|
Type: protocol.ChatPartTool,
|
|
ID: "claude-error-" + turn,
|
|
Name: "Claude Code",
|
|
State: &protocol.ChatToolState{Status: protocol.ChatToolError, Error: &protocol.ChatError{Type: "prompt", Message: boundedText(diagnostic, 2<<10)}},
|
|
},
|
|
})
|
|
}
|
|
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, TurnID: turn}})
|
|
}
|
|
|
|
func (s *session) ensureProcess(ctx context.Context) (*process, error) {
|
|
for {
|
|
s.mu.Lock()
|
|
if s.proc != nil {
|
|
p := s.proc
|
|
s.lastUsed = time.Now()
|
|
s.mu.Unlock()
|
|
s.awaitReady(ctx)
|
|
return p, nil
|
|
}
|
|
if s.starting != nil {
|
|
wait := s.starting
|
|
s.mu.Unlock()
|
|
select {
|
|
case <-wait:
|
|
continue
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
}
|
|
}
|
|
wait := make(chan struct{})
|
|
s.starting = wait
|
|
s.startErr = nil
|
|
s.mu.Unlock()
|
|
p, err := s.spawn(ctx)
|
|
s.mu.Lock()
|
|
if err == nil {
|
|
s.proc = p
|
|
} else {
|
|
s.startErr = err
|
|
}
|
|
s.starting = nil
|
|
close(wait)
|
|
s.mu.Unlock()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return p, nil
|
|
}
|
|
}
|
|
|
|
// Stream subscribes to the session's live frames. History is loaded separately
|
|
// through Messages; a client attaching mid-turn is told to resync.
|
|
func (c *Chat) Stream(ctx context.Context, id string, ready func(), emit func(protocol.ChatEventFrame) error) error {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
meta, ok := transcriptSession(id)
|
|
if !ok {
|
|
return errors.New("unknown Claude session " + id)
|
|
}
|
|
s = c.sessionFor(id, meta.Directory)
|
|
}
|
|
ch := s.subscribe()
|
|
defer s.unsubscribe(ch)
|
|
if ready != nil {
|
|
ready()
|
|
}
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case frame, ok := <-ch:
|
|
if !ok {
|
|
return errors.New("Claude chat stream closed")
|
|
}
|
|
if err := emit(frame); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TurnRunning reports whether the CLI is working on a turn for id, so a client
|
|
// that attaches mid-turn (a page reload) still shows the turn running although
|
|
// its step-started frame was emitted before that client subscribed.
|
|
func (c *Chat) TurnRunning(id string) bool {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return false
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.running
|
|
}
|
|
|
|
// Interrupt asks the CLI to cancel the in-flight turn, including queued turns.
|
|
func (c *Chat) Interrupt(ctx context.Context, id string) error {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
s.awaitReady(ctx)
|
|
s.mu.Lock()
|
|
proc := s.proc
|
|
running := s.running
|
|
s.mu.Unlock()
|
|
if proc == nil || !running {
|
|
return nil
|
|
}
|
|
requestCtx, cancel := context.WithTimeout(ctx, controlRequestTimeout)
|
|
defer cancel()
|
|
_, err := proc.request(requestCtx, "interrupt", map[string]any{"cancel_queued": true})
|
|
return err
|
|
}
|
|
|
|
// ActivateSkill has no out-of-band equivalent in Claude Code; skills resolve
|
|
// through the CLI's own /skill mechanism.
|
|
func (c *Chat) ActivateSkill(context.Context, string, string) error {
|
|
return errors.New("Claude Code has no out-of-band skill activation")
|
|
}
|
|
|
|
// Models lists the CLI's own model choices, loaded at the initialize handshake.
|
|
func (c *Chat) Models(ctx context.Context, id string) ([]protocol.ChatModel, error) {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return nil, errors.New("unknown Claude session " + id)
|
|
}
|
|
proc, err := s.ensureProcess(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_ = proc
|
|
s.mu.Lock()
|
|
models := append([]protocol.ChatModel(nil), s.models...)
|
|
s.mu.Unlock()
|
|
if len(models) == 0 {
|
|
return nil, errors.New("Claude Code reported no available models")
|
|
}
|
|
return models, nil
|
|
}
|
|
|
|
// SwitchModel changes the model for subsequent turns. The CLI applies it live
|
|
// when a process exists; otherwise the next process starts with it.
|
|
func (c *Chat) SwitchModel(ctx context.Context, id, provider, model string) error {
|
|
if provider != "" && provider != Backend {
|
|
return errors.New("Claude models use the claude provider")
|
|
}
|
|
model = strings.TrimSpace(model)
|
|
if model == "" {
|
|
return errors.New("a model is required")
|
|
}
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return errors.New("unknown Claude session " + id)
|
|
}
|
|
s.mu.Lock()
|
|
previous := s.model
|
|
s.model = model
|
|
proc := s.proc
|
|
applied := s.appliedModel
|
|
s.mu.Unlock()
|
|
if proc != nil && model != applied {
|
|
requestCtx, cancel := context.WithTimeout(ctx, controlRequestTimeout)
|
|
defer cancel()
|
|
if _, err := proc.request(requestCtx, "set_model", map[string]any{"model": model}); err != nil {
|
|
s.mu.Lock()
|
|
s.model = previous
|
|
s.mu.Unlock()
|
|
return fmt.Errorf("switch Claude model: %w", err)
|
|
}
|
|
s.mu.Lock()
|
|
s.appliedModel = model
|
|
s.mu.Unlock()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Permissions returns the approvals still waiting for an operator answer.
|
|
func (c *Chat) Permissions(ctx context.Context, id string) ([]protocol.ChatPermissionFrame, error) {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return []protocol.ChatPermissionFrame{}, nil
|
|
}
|
|
s.awaitReady(ctx)
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
frames := make([]protocol.ChatPermissionFrame, 0, len(s.approvals))
|
|
for _, approval := range s.approvals {
|
|
frames = append(frames, approval.frame)
|
|
}
|
|
sort.Slice(frames, func(i, j int) bool { return frames[i].RequestID < frames[j].RequestID })
|
|
return frames, nil
|
|
}
|
|
|
|
// Forms returns the pending operator questions.
|
|
func (c *Chat) Forms(ctx context.Context, id string) ([]protocol.ChatForm, error) {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
return []protocol.ChatForm{}, nil
|
|
}
|
|
s.awaitReady(ctx)
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
forms := make([]protocol.ChatForm, 0, len(s.forms))
|
|
for _, form := range s.forms {
|
|
forms = append(forms, form.form)
|
|
}
|
|
sort.Slice(forms, func(i, j int) bool { return forms[i].ID < forms[j].ID })
|
|
return forms, nil
|
|
}
|
|
|
|
// Reply delivers one approval decision to the waiting CLI process.
|
|
func (c *Chat) Reply(ctx context.Context, request protocol.ChatReplyRequest) error {
|
|
s := c.session(request.SessionID)
|
|
if s == nil {
|
|
return errors.New("unknown Claude session " + request.SessionID)
|
|
}
|
|
s.mu.Lock()
|
|
approval, ok := s.approvals[request.RequestID]
|
|
if !ok || approval.answering {
|
|
s.mu.Unlock()
|
|
return errors.New("the Claude approval is no longer awaiting an answer")
|
|
}
|
|
proc := approval.proc
|
|
var response any
|
|
switch request.Decision {
|
|
case protocol.ChatDecisionOnce:
|
|
response = map[string]any{"behavior": "allow", "updatedInput": approval.input}
|
|
case protocol.ChatDecisionAlways:
|
|
response = map[string]any{"behavior": "allow", "updatedInput": approval.input}
|
|
if len(approval.suggestions) > 0 && string(approval.suggestions) != "null" {
|
|
response = map[string]any{"behavior": "allow", "updatedInput": approval.input, "updatedPermissions": approval.suggestions}
|
|
}
|
|
case protocol.ChatDecisionReject:
|
|
response = map[string]any{"behavior": "deny", "message": "Denied by the operator"}
|
|
default:
|
|
s.mu.Unlock()
|
|
return errors.New("invalid approval decision")
|
|
}
|
|
if proc == nil {
|
|
s.mu.Unlock()
|
|
return errProcessClosed
|
|
}
|
|
approval.answering = true
|
|
s.mu.Unlock()
|
|
err := proc.respond(request.RequestID, response)
|
|
s.mu.Lock()
|
|
if err == nil {
|
|
delete(s.approvals, request.RequestID)
|
|
} else if current, exists := s.approvals[request.RequestID]; exists {
|
|
current.answering = false
|
|
}
|
|
s.mu.Unlock()
|
|
return err
|
|
}
|
|
|
|
// Answer delivers a question answer (or declines it) to the waiting CLI.
|
|
func (c *Chat) Answer(ctx context.Context, request protocol.ChatAnswerRequest) error {
|
|
s := c.session(request.SessionID)
|
|
if s == nil {
|
|
return errors.New("unknown Claude session " + request.SessionID)
|
|
}
|
|
s.mu.Lock()
|
|
form, ok := s.forms[request.FormID]
|
|
if !ok || form.answering {
|
|
s.mu.Unlock()
|
|
return errors.New("the Claude question is no longer awaiting an answer")
|
|
}
|
|
proc := form.proc
|
|
s.mu.Unlock()
|
|
if proc == nil {
|
|
return errProcessClosed
|
|
}
|
|
deny := request.Action == "cancel" || request.Action == "decline"
|
|
var response any
|
|
if deny {
|
|
response = map[string]any{"behavior": "deny", "message": "The operator declined to answer"}
|
|
} else {
|
|
answers := map[string]string{}
|
|
for index, question := range form.questions {
|
|
key := fmt.Sprintf("q%d", index)
|
|
value, present := request.Answers[key]
|
|
if !present {
|
|
continue
|
|
}
|
|
switch typed := value.(type) {
|
|
case string:
|
|
answers[question] = typed
|
|
case []any:
|
|
labels := make([]string, 0, len(typed))
|
|
for _, item := range typed {
|
|
labels = append(labels, fmt.Sprint(item))
|
|
}
|
|
answers[question] = strings.Join(labels, ", ")
|
|
case []string:
|
|
answers[question] = strings.Join(typed, ", ")
|
|
default:
|
|
answers[question] = fmt.Sprint(typed)
|
|
}
|
|
}
|
|
response = map[string]any{
|
|
"behavior": "allow",
|
|
"updatedInput": map[string]any{"questions": form.rawQuestions, "answers": answers},
|
|
}
|
|
}
|
|
s.mu.Lock()
|
|
form.answering = true
|
|
s.mu.Unlock()
|
|
err := proc.respond(request.FormID, response)
|
|
s.mu.Lock()
|
|
if err == nil {
|
|
delete(s.forms, request.FormID)
|
|
} else if current, exists := s.forms[request.FormID]; exists {
|
|
current.answering = false
|
|
}
|
|
s.mu.Unlock()
|
|
return err
|
|
}
|
|
|
|
// Shells lists the commands still running in the session.
|
|
func (c *Chat) Shells(ctx context.Context, id string) ([]protocol.ChatShell, error) {
|
|
s, err := c.retainedSessionReadback(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if s == nil {
|
|
return []protocol.ChatShell{}, nil
|
|
}
|
|
s.enrichShellStarts()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if p := s.proc; p != nil && p.link != nil && p.link.tasksIncomplete.Load() {
|
|
return nil, errors.New("Claude Code background task readback is incomplete: the legacy host trimmed replay without an authoritative task snapshot")
|
|
}
|
|
result := []protocol.ChatShell{}
|
|
for _, snapshot := range s.shells {
|
|
if snapshot.shell.Status == protocol.ChatShellRunning {
|
|
result = append(result, snapshot.shell)
|
|
}
|
|
}
|
|
sort.Slice(result, func(i, j int) bool { return result[i].ID < result[j].ID })
|
|
return result, nil
|
|
}
|
|
|
|
// ShellOutput pages the retained output of one command this session started.
|
|
func (c *Chat) ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, error) {
|
|
if query.Cursor < 0 || query.Cursor > protocol.ChatShellOutputMaxCursor || query.Limit <= 0 || query.Limit > protocol.ChatShellOutputLimit {
|
|
return protocol.ChatShellOutputPage{}, errors.New("invalid bounded Claude output query")
|
|
}
|
|
s := c.session(query.SessionID)
|
|
if s == nil {
|
|
return protocol.ChatShellOutputPage{Shell: protocol.ChatShell{ID: query.ShellID}, Unavailable: true}, nil
|
|
}
|
|
s.mu.Lock()
|
|
var snapshot *shellSnapshot
|
|
for _, candidate := range s.shells {
|
|
if candidate.shell.ID == query.ShellID {
|
|
snapshot = candidate
|
|
break
|
|
}
|
|
}
|
|
s.mu.Unlock()
|
|
if snapshot == nil {
|
|
return protocol.ChatShellOutputPage{Shell: protocol.ChatShell{ID: query.ShellID}, Unavailable: true}, nil
|
|
}
|
|
start := query.Cursor
|
|
if start > int64(len(snapshot.output)) {
|
|
start = int64(len(snapshot.output))
|
|
}
|
|
end := start + int64(query.Limit)
|
|
if end > int64(len(snapshot.output)) {
|
|
end = int64(len(snapshot.output))
|
|
}
|
|
return protocol.ChatShellOutputPage{
|
|
Shell: snapshot.shell,
|
|
Output: snapshot.output[start:end],
|
|
Cursor: end,
|
|
Size: snapshot.size,
|
|
Truncated: end < snapshot.size,
|
|
}, nil
|
|
}
|
|
|
|
// ---- CLI request handling --------------------------------------------------
|
|
|
|
type pendingApproval struct {
|
|
frame protocol.ChatPermissionFrame
|
|
input json.RawMessage
|
|
suggestions json.RawMessage
|
|
proc *process
|
|
answering bool
|
|
}
|
|
|
|
type pendingForm struct {
|
|
form protocol.ChatForm
|
|
rawQuestions json.RawMessage
|
|
questions []string
|
|
proc *process
|
|
answering bool
|
|
}
|
|
|
|
func (s *session) receivePermission(p *process, requestID string, request toolRequest) {
|
|
if requestID == "" {
|
|
return
|
|
}
|
|
if request.ToolName == "AskUserQuestion" {
|
|
s.receiveQuestion(p, requestID, request)
|
|
return
|
|
}
|
|
frame := protocol.ChatPermissionFrame{
|
|
SessionID: s.id,
|
|
RequestID: requestID,
|
|
Action: request.ToolName,
|
|
Source: &protocol.ChatPermissionSource{Type: "tool", ID: request.ToolUseID},
|
|
}
|
|
if name := request.DisplayName; name != "" && name != request.ToolName {
|
|
frame.Action = name
|
|
}
|
|
if request.Description != "" {
|
|
frame.Message = request.Description
|
|
}
|
|
frame.Resources = append(frame.Resources, permissionResources(request.ToolName, request.Input)...)
|
|
if len(request.PermissionSuggestions) > 0 && string(request.PermissionSuggestions) != "null" {
|
|
frame.AlwaysLabel = "Always allow"
|
|
}
|
|
s.mu.Lock()
|
|
s.approvals[requestID] = &pendingApproval{frame: frame, input: request.Input, suggestions: request.PermissionSuggestions, proc: p}
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func permissionResources(tool string, input json.RawMessage) []string {
|
|
var fields map[string]any
|
|
_ = json.Unmarshal(input, &fields)
|
|
text := func(key string) string {
|
|
if value, ok := fields[key].(string); ok {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
return ""
|
|
}
|
|
switch tool {
|
|
case "Bash":
|
|
if command := text("command"); command != "" {
|
|
return []string{command}
|
|
}
|
|
case "Write", "Edit", "NotebookEdit", "Read":
|
|
if path := text("file_path"); path != "" {
|
|
return []string{path}
|
|
}
|
|
if path := text("notebook_path"); path != "" {
|
|
return []string{path}
|
|
}
|
|
case "WebFetch":
|
|
if target := text("url"); target != "" {
|
|
return []string{target}
|
|
}
|
|
case "WebSearch":
|
|
if query := text("query"); query != "" {
|
|
return []string{query}
|
|
}
|
|
}
|
|
// Fall back to a bounded, human-readable input summary so the operator sees
|
|
// what is being approved instead of an empty card.
|
|
bounded := boundedText(string(input), 1<<10)
|
|
if strings.TrimSpace(bounded) == "" {
|
|
return nil
|
|
}
|
|
return []string{bounded}
|
|
}
|
|
|
|
func (s *session) receiveQuestion(p *process, requestID string, request toolRequest) {
|
|
var payload struct {
|
|
Questions []struct {
|
|
Question string `json:"question"`
|
|
Header string `json:"header"`
|
|
MultiSelect bool `json:"multiSelect"`
|
|
Options []struct {
|
|
Label string `json:"label"`
|
|
Description string `json:"description"`
|
|
} `json:"options"`
|
|
} `json:"questions"`
|
|
}
|
|
if json.Unmarshal(request.Input, &payload) != nil || len(payload.Questions) == 0 {
|
|
// A question we cannot represent must not silently vanish: surface it as
|
|
// an approval card whose only useful action is deny.
|
|
s.receivePermission(p, requestID, toolRequest{ToolName: "AskUserQuestion", Input: request.Input})
|
|
return
|
|
}
|
|
form := protocol.ChatForm{ID: requestID, SessionID: s.id, Kind: "question", Title: "Claude asked a question"}
|
|
questions := make([]string, 0, len(payload.Questions))
|
|
for index, question := range payload.Questions {
|
|
questions = append(questions, question.Question)
|
|
field := protocol.ChatFormField{
|
|
Key: fmt.Sprintf("q%d", index),
|
|
Title: question.Question,
|
|
Type: "string",
|
|
Required: true,
|
|
}
|
|
if question.Header != "" {
|
|
form.Title = question.Header
|
|
}
|
|
if question.MultiSelect {
|
|
field.Type = "multiselect"
|
|
}
|
|
for _, option := range question.Options {
|
|
field.Options = append(field.Options, protocol.ChatFormOption{Value: option.Label, Label: option.Label, Description: option.Description})
|
|
}
|
|
form.Fields = append(form.Fields, field)
|
|
}
|
|
s.mu.Lock()
|
|
s.forms[requestID] = &pendingForm{form: form, rawQuestions: request.Input, questions: questions, proc: p}
|
|
s.mu.Unlock()
|
|
s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventForm, Form: &form})
|
|
}
|