103 lines
2.9 KiB
Go
103 lines
2.9 KiB
Go
package bot
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"sync"
|
|
|
|
"slackerbot/internal/model"
|
|
"slackerbot/internal/tools"
|
|
)
|
|
|
|
const maxReplyBytes = 1 << 20
|
|
|
|
// agentCommands runs the Slack commands the agent calls as tools during one
|
|
// turn, as the person whose message started it. Only stop waits for the turn
|
|
// to end, because stopping the container would cut the reply off.
|
|
type agentCommands struct {
|
|
b *Bot
|
|
u *model.Owner
|
|
m incoming
|
|
root string
|
|
|
|
wg sync.WaitGroup
|
|
mu sync.Mutex
|
|
stopWhen bool
|
|
}
|
|
|
|
func (b *Bot) agentCommands(u *model.Owner, m incoming, root string) *agentCommands {
|
|
m.threadTS = root
|
|
return &agentCommands{b: b, u: u, m: m, root: root}
|
|
}
|
|
|
|
// Update must not block: it's called from the ACP read loop.
|
|
func (a *agentCommands) Update(ctx context.Context, up acpUpdate) {
|
|
c, args, ok := tools.CommandCall(up)
|
|
if !ok || c.Missing(args) {
|
|
return
|
|
}
|
|
a.wg.Add(1)
|
|
go func() {
|
|
defer a.wg.Done()
|
|
reply, isErr := a.run(ctx, c, args)
|
|
a.answer(ctx, c, args, reply, isErr)
|
|
}()
|
|
}
|
|
|
|
func (a *agentCommands) run(ctx context.Context, c tools.SlackCommand, args string) (string, bool) {
|
|
text := c.Text(args)
|
|
log.Printf("agent: %s ran %q for %s in %s/%s", a.u.Machine, text, a.m.user, a.m.channel, a.root)
|
|
if c.Name == tools.Stop {
|
|
return a.queueStop(), false
|
|
}
|
|
verb, rest := splitCommand(text)
|
|
var reply string
|
|
var ok bool
|
|
if c.Name == tools.Move {
|
|
reply, ok = a.b.move(ctx, a.m, rest, a.root, true)
|
|
} else {
|
|
reply, ok = a.b.runCommand(ctx, a.m, verb, rest, true)
|
|
}
|
|
if !ok {
|
|
return fmt.Sprintf("`%s` isn't something slackerbot understands. Check the tool's description for the args it takes.", text), true
|
|
}
|
|
if c.Changes(args) && c.Name != tools.Move {
|
|
a.b.say(ctx, a.m.channel, a.root, fmt.Sprintf(":robot_face: The agent ran `%s` for %s:\n%s", text, a.b.displayName(ctx, a.m.user), reply))
|
|
}
|
|
return reply, false
|
|
}
|
|
|
|
func (a *agentCommands) queueStop() string {
|
|
if a.b.store.Owner(a.u.ID) == nil {
|
|
return "There's no container to stop."
|
|
}
|
|
a.mu.Lock()
|
|
a.stopWhen = true
|
|
a.mu.Unlock()
|
|
return "The container will shut down as soon as this reply ends. Its files are kept, and the next message starts it again."
|
|
}
|
|
|
|
func (a *agentCommands) answer(ctx context.Context, c tools.SlackCommand, args, text string, isErr bool) {
|
|
data, _ := json.Marshal(tools.Reply{Text: text, Error: isErr})
|
|
p := tools.ReplyPath(a.b.cfg.AgentCwd, c.Name, args)
|
|
if err := a.b.mgr.WriteFile(ctx, a.u, p, maxReplyBytes, bytes.NewReader(data)); err != nil {
|
|
log.Printf("agent: answering %s in %s: %v", c.Name, a.u.Machine, err)
|
|
}
|
|
}
|
|
|
|
// Finish waits for the turn's commands, then does what had to wait for the turn to end.
|
|
func (a *agentCommands) Finish(ctx context.Context) {
|
|
a.wg.Wait()
|
|
a.mu.Lock()
|
|
stop := a.stopWhen
|
|
a.mu.Unlock()
|
|
if !stop {
|
|
return
|
|
}
|
|
reply := a.b.stopFor(ctx, a.u.ID)
|
|
a.b.say(ctx, a.m.channel, a.root, fmt.Sprintf(":robot_face: The agent ran `stop` for %s:\n%s", a.b.displayName(ctx, a.m.user), reply))
|
|
}
|