Files

90 lines
2.7 KiB
Go

package claude
import (
"context"
"errors"
"fmt"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// defaultMode is Claude Code's own ask-for-permission mode. The CLI flag has no
// spelling for it, so a process in this mode is started without the flag; the
// control request accepts it by name.
const defaultMode = "default"
// chatModes are the Claude Code permission modes a chat can run in, in the
// order the CLI cycles them. dontAsk is left out: it silently denies anything
// not pre-approved, which a chat on a phone cannot recover from.
var chatModes = []protocol.ChatMode{
{ID: defaultMode, Name: "Ask for permission", Description: "Ask before edits and commands."},
{ID: "acceptEdits", Name: "Accept edits", Description: "Make file edits without asking; ask for other actions."},
{ID: "plan", Name: "Plan", Description: "Explore and plan without changing anything."},
{ID: "auto", Name: "Auto", Description: "Act without asking, with Claude Code's safety checks."},
{ID: "bypassPermissions", Name: "Bypass permissions", Description: "Never ask. Everything runs without checks."},
}
// Modes lists the permission modes a Claude chat can switch to.
func (c *Chat) Modes(context.Context, string) ([]protocol.ChatMode, error) {
return append([]protocol.ChatMode(nil), chatModes...), nil
}
func knownMode(mode string) bool {
for _, known := range chatModes {
if known.ID == mode {
return true
}
}
return false
}
// SetMode records the session's permission mode and applies it to a running
// CLI at once; a later process starts in it.
func (c *Chat) SetMode(ctx context.Context, id, mode string) error {
if !knownMode(mode) {
return fmt.Errorf("unknown Claude permission mode %q", mode)
}
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)
}
s.mu.Lock()
previous := s.mode
s.mode = mode
proc := s.proc
s.mu.Unlock()
if proc == nil {
return nil
}
if err := s.applyMode(ctx, proc); err != nil {
s.mu.Lock()
s.mode = previous
s.mu.Unlock()
return err
}
return nil
}
// applyMode tells a running CLI the session's mode when it runs in another.
func (s *session) applyMode(ctx context.Context, proc *process) error {
s.mu.Lock()
requested, current := s.mode, proc.mode
s.mu.Unlock()
if requested == "" || requested == current || (current == "" && requested == defaultMode) {
return nil
}
setCtx, cancel := context.WithTimeout(ctx, controlRequestTimeout)
defer cancel()
if _, err := proc.request(setCtx, "set_permission_mode", map[string]any{"mode": requested}); err != nil {
return fmt.Errorf("switch Claude permission mode: %w", err)
}
s.mu.Lock()
proc.mode = requested
s.mu.Unlock()
return nil
}