355b722a1d
Commands start in a PTY (creack/pty; macOS and Linux) of the client's size with TERM=xterm-256color in their own session. chat_shell_input writes typed UTF-8 text in order through a bounded queue; chat_shell_resize sets the size. Output stays the raw terminal stream with byte offsets as sequence numbers, chat_shell_run_output resumes from an offset, and a plain-text rendering is persisted for Copy output and Send to agent. Input is never stored or logged.
177 lines
6.1 KiB
Go
177 lines
6.1 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// handleChatShellRunRequest answers the operator shell-command requests. Every
|
|
// one names an operator chat session the registry records: the command runs
|
|
// only in that chat's own directory on this server's machine, and a run is
|
|
// only readable, stoppable or typed into through the session that started it.
|
|
// Any authenticated client of that session may type into a running command,
|
|
// not only the one that started it.
|
|
func handleChatShellRunRequest(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) {
|
|
fail := func(err error) { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) }
|
|
runner := hub.shellRunner()
|
|
if runner == nil {
|
|
fail(errors.New("shell commands are not configured on this server"))
|
|
return
|
|
}
|
|
var sessionID string
|
|
body := request.ChatShellRunRequest
|
|
switch {
|
|
case request.Type == protocol.ChatShellRuns && request.ChatQuery != nil:
|
|
sessionID = request.ChatQuery.SessionID
|
|
case body != nil:
|
|
sessionID = body.SessionID
|
|
}
|
|
if !validChatSessionID(sessionID) {
|
|
fail(errors.New("a valid chat session id is required"))
|
|
return
|
|
}
|
|
if registry == nil {
|
|
fail(errors.New("operator session registry is not configured on this server"))
|
|
return
|
|
}
|
|
session, found, err := registry.OperatorSession(ctx, sessionID)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
if !found {
|
|
fail(errors.New("operator session is not available"))
|
|
return
|
|
}
|
|
if request.Type != protocol.ChatShellRuns && body == nil {
|
|
fail(errors.New("a chat shell request body is required"))
|
|
return
|
|
}
|
|
switch request.Type {
|
|
case protocol.ChatShellRun:
|
|
record, err := runner.Start(ctx, sessionID, session.Directory, body.Command, body.Cols, body.Rows)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatShellRun, ID: request.ID, ChatShellRun: &record})
|
|
case protocol.ChatShellStop:
|
|
record, err := runner.Stop(sessionID, body.RunID)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatShellStop, ID: request.ID, ChatShellRun: &record})
|
|
case protocol.ChatShellRuns:
|
|
runs, err := runner.List(ctx, sessionID)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatShellRuns, ID: request.ID, ChatShellRuns: runs})
|
|
case protocol.ChatShellInput:
|
|
if err := runner.Input(sessionID, body.RunID, body.Data); err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatShellInput, ID: request.ID})
|
|
case protocol.ChatShellResize:
|
|
record, err := runner.Resize(sessionID, body.RunID, body.Cols, body.Rows)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatShellResize, ID: request.ID, ChatShellRun: &record})
|
|
case protocol.ChatShellRunOutput:
|
|
record, err := runner.Read(ctx, sessionID, body.RunID)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
record = chatShellRecordAfter(record, body.After)
|
|
_ = write(protocol.Message{Type: protocol.ChatShellRunOutput, ID: request.ID, ChatShellRun: &record})
|
|
case protocol.ChatShellShare:
|
|
record, err := runner.Read(ctx, sessionID, body.RunID)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
if record.Status == protocol.ChatShellRunRunning {
|
|
fail(errors.New("wait for the command to finish before sending it to the agent"))
|
|
return
|
|
}
|
|
prompt := protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatPrompt: &protocol.ChatPromptRequest{
|
|
SessionID: sessionID, Text: chatShellSharePrompt(record), OperationID: body.OperationID,
|
|
}}
|
|
admitChatPrompt(ctx, prompt, broker, hub, registry, clientID, write, true)
|
|
}
|
|
}
|
|
|
|
// List is the session's recorded runs, oldest first. A running run carries
|
|
// its live output rather than the last periodic save; every run carries at
|
|
// most protocol.ChatShellRunListOutput bytes of its tail.
|
|
func (r *chatShellRunner) List(ctx context.Context, sessionID string) ([]protocol.ChatShellRunRecord, error) {
|
|
runs, err := r.store.ChatShellRuns(ctx, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for i, run := range runs {
|
|
if p := r.activeProcess(sessionID, run.ID); p != nil {
|
|
runs[i] = p.snapshot(protocol.ChatShellRunListOutput)
|
|
} else {
|
|
runs[i] = chatShellRecordTail(run, protocol.ChatShellRunListOutput)
|
|
}
|
|
runs[i].Text = ""
|
|
}
|
|
return runs, nil
|
|
}
|
|
|
|
// Read is one run of sessionID with its whole retained output.
|
|
func (r *chatShellRunner) Read(ctx context.Context, sessionID, runID string) (protocol.ChatShellRunRecord, error) {
|
|
if p := r.activeProcess(sessionID, runID); p != nil {
|
|
return p.snapshot(protocol.ChatShellRunRetained), nil
|
|
}
|
|
record, found, err := r.store.ChatShellRun(ctx, sessionID, runID)
|
|
if err != nil {
|
|
return protocol.ChatShellRunRecord{}, err
|
|
}
|
|
if !found {
|
|
return protocol.ChatShellRunRecord{}, errors.New("this chat has no such command")
|
|
}
|
|
if record.Text == "" && record.Output != "" {
|
|
// A run recorded before plain-text renderings were stored.
|
|
record.Text = chatShellPlainText(record.Output)
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
// chatShellRecordAfter keeps only the output from absolute byte after on; an
|
|
// offset before the retained tail keeps all of it (OutputStart says where it
|
|
// starts, so the reader sees the gap).
|
|
func chatShellRecordAfter(record protocol.ChatShellRunRecord, after int64) protocol.ChatShellRunRecord {
|
|
if after <= record.OutputStart {
|
|
return record
|
|
}
|
|
skip := min(after-record.OutputStart, int64(len(record.Output)))
|
|
cut := runeStartAfter([]byte(record.Output), int(skip))
|
|
record.Output = record.Output[cut:]
|
|
record.OutputStart += int64(cut)
|
|
return record
|
|
}
|
|
|
|
// chatShellRecordTail trims a stored record's output to its last max bytes.
|
|
func chatShellRecordTail(record protocol.ChatShellRunRecord, max int) protocol.ChatShellRunRecord {
|
|
if len(record.Output) <= max {
|
|
return record
|
|
}
|
|
out := newChatShellOutput(len(record.Output))
|
|
out.write([]byte(record.Output))
|
|
text, from := out.tail(max)
|
|
record.Output = text
|
|
record.OutputStart += from
|
|
record.Truncated = true
|
|
return record
|
|
}
|