restart fix + slack commands
This commit is contained in:
1 parent
e90c9f324b
commit
25fcf85855
22 files changed
+1077
-119
No files matched your search
@@ -3,6 +3,7 @@ load("@rules_go//go:def.bzl", "go_library", "go_test")
|
||||
go_library(
|
||||
name = "bot",
|
||||
srcs = [
|
||||
"agent.go",
|
||||
"assistant.go",
|
||||
"bot.go",
|
||||
"files.go",
|
||||
@@ -10,6 +11,7 @@ go_library(
|
||||
"listen.go",
|
||||
"manage.go",
|
||||
"stream.go",
|
||||
"update.go",
|
||||
"version.go",
|
||||
],
|
||||
importpath = "slackerbot/internal/bot",
|
||||
@@ -36,8 +38,10 @@ go_library(
|
||||
go_test(
|
||||
name = "bot_test",
|
||||
srcs = [
|
||||
"agent_test.go",
|
||||
"bot_test.go",
|
||||
"lifecycle_test.go",
|
||||
"update_test.go",
|
||||
"version_test.go",
|
||||
],
|
||||
embed = [":bot"],
|
||||
@@ -50,6 +54,7 @@ go_test(
|
||||
"//slackerbot/internal/state",
|
||||
"//slackerbot/internal/testutil",
|
||||
"//slackerbot/internal/testutil/clustertest",
|
||||
"//slackerbot/internal/tools",
|
||||
"@com_github_slack_go_slack//:slack",
|
||||
"@com_github_slack_go_slack//slackevents",
|
||||
],
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
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))
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
package bot
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/slack-go/slack"
|
||||
|
||||
"slackerbot/internal/acp"
|
||||
"slackerbot/internal/manager"
|
||||
"slackerbot/internal/model"
|
||||
"slackerbot/internal/testutil"
|
||||
"slackerbot/internal/testutil/clustertest"
|
||||
"slackerbot/internal/tools"
|
||||
)
|
||||
|
||||
func TestAgentRunsCommandsAsTheSender(t *testing.T) {
|
||||
c := clustertest.New(t)
|
||||
c.Cfg.AgentCwd = "/root"
|
||||
c.Cfg.IdleTimeout = 6 * time.Hour
|
||||
c.Cfg.MaxIdleTimeout = 7 * 24 * time.Hour
|
||||
c.AddOwner(t, testutil.HomeData(), true)
|
||||
c.Store.SeedPermissions(model.PermissionsConfig{Managers: []string{"UBOSS"}, Default: map[string][]string{"UBOSS": {"all"}}})
|
||||
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
||||
srv := httptest.NewServer(log)
|
||||
defer srv.Close()
|
||||
b := &Bot{cfg: c.Cfg, store: c.Store, mgr: c.Mgr, api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/")),
|
||||
acps: map[string]*acp.ACP{}, busy: map[string]int{}}
|
||||
|
||||
call := func(user, tool, args string) (tools.Reply, bool) {
|
||||
u := c.Store.Owner("C1")
|
||||
cmds := b.agentCommands(u, incoming{user: user, channel: "C1", ts: "5.0"}, "5.0")
|
||||
raw, _ := json.Marshal(map[string]string{"args": args})
|
||||
cmds.Update(c.Ctx, acp.Update{Kind: "tool_call", ToolID: "1", ToolName: "slackerbot__" + tool, RawInput: raw})
|
||||
cmds.Finish(c.Ctx)
|
||||
c.Master.Mu.Lock()
|
||||
defer c.Master.Mu.Unlock()
|
||||
for key, data := range c.Master.Files {
|
||||
if strings.HasPrefix(key, "/d/c-c1/.slackerbot/replies/") {
|
||||
delete(c.Master.Files, key)
|
||||
var r tools.Reply
|
||||
_ = json.Unmarshal(data, &r)
|
||||
return r, true
|
||||
}
|
||||
}
|
||||
return tools.Reply{}, false
|
||||
}
|
||||
|
||||
if r, ok := call("UBOSS", "keep", "3h"); !ok || !strings.Contains(r.Text, "3h") {
|
||||
t.Fatalf("keep: %+v %v", r, ok)
|
||||
}
|
||||
if got := c.Store.Owner("C1").IdleTimeout; got != 3*time.Hour {
|
||||
t.Fatalf("keep wasn't saved: %s", got)
|
||||
}
|
||||
if r, _ := call("UANA", "scale", "up"); !strings.Contains(r.Text, ":lock:") {
|
||||
t.Fatalf("the sender's permissions apply: %+v", r)
|
||||
}
|
||||
if r, _ := call("UANA", "status", ""); !strings.Contains(r.Text, "This channel's container") {
|
||||
t.Fatalf("status: %+v", r)
|
||||
}
|
||||
if r, _ := call("UANA", "scale", "the tests"); !r.Error {
|
||||
t.Fatalf("nonsense args should be an error: %+v", r)
|
||||
}
|
||||
if r, _ := call("UANA", "stop", ""); !strings.Contains(r.Text, "as soon as this reply ends") {
|
||||
t.Fatalf("stop: %+v", r)
|
||||
}
|
||||
testutil.WaitFor(t, "container to stop", func() bool { return c.Mgr.State(c.Store.Owner("C1")) != manager.StateRunning })
|
||||
|
||||
log.mu.Lock()
|
||||
defer log.mu.Unlock()
|
||||
var seen []string
|
||||
for _, ts := range log.order {
|
||||
if log.under[ts] == "5.0" && strings.Contains(log.text[ts], "The agent ran") {
|
||||
seen = append(seen, log.text[ts])
|
||||
}
|
||||
}
|
||||
if len(seen) != 3 || !strings.Contains(seen[0], "`keep 3h`") || !strings.Contains(seen[1], ":lock:") || !strings.Contains(seen[2], "`stop`") {
|
||||
t.Fatalf("changes should be posted in the thread, got %q", seen)
|
||||
}
|
||||
}
|
||||
+116
-55
@@ -72,6 +72,8 @@ type Bot struct {
|
||||
busy map[string]int
|
||||
names sync.Map
|
||||
|
||||
updateAsked sync.Map // machine → asked to restart onto a newer system
|
||||
|
||||
channels sync.Map // channel ID → *slack.Channel
|
||||
running sync.Map // "channel/ts" of a prompt's message or reply → its cancel func
|
||||
viewing sync.Map // assistant "channel/thread" → channel the user has open
|
||||
@@ -326,8 +328,10 @@ func (b *Bot) onMessage(ctx context.Context, m incoming) {
|
||||
}
|
||||
st := NewStreamer(b.api, m.channel, root, ph)
|
||||
var sends tools.Calls
|
||||
cmds := b.agentCommands(u, m, root)
|
||||
stop, err := acp.Prompt(pctx, id, text, func(up acpUpdate) {
|
||||
sends.Update(up)
|
||||
cmds.Update(ctx, up)
|
||||
st.Update(up)
|
||||
})
|
||||
if pctx.Err() != nil && ctx.Err() == nil {
|
||||
@@ -335,7 +339,9 @@ func (b *Bot) onMessage(ctx context.Context, m incoming) {
|
||||
}
|
||||
st.Finish(stop, err)
|
||||
b.upload(ctx, u, m.channel, root, sends.Files())
|
||||
cmds.Finish(ctx)
|
||||
_ = b.store.Touch(u.ID)
|
||||
b.offerUpdate(ctx, u, m.channel, root)
|
||||
switch {
|
||||
case stop == "cancelled":
|
||||
outcome = ""
|
||||
@@ -344,28 +350,51 @@ func (b *Bot) onMessage(ctx context.Context, m incoming) {
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Bot) command(ctx context.Context, m incoming) bool {
|
||||
ownerID, kind := m.owner()
|
||||
verb, args, _ := strings.Cut(strings.TrimSpace(m.text), " ")
|
||||
func splitCommand(text string) (verb, args string) {
|
||||
verb, args, _ = strings.Cut(strings.TrimSpace(text), " ")
|
||||
verb = strings.ToLower(strings.TrimRight(verb, ".!?"))
|
||||
args = strings.TrimRight(strings.TrimSpace(args), " .!?")
|
||||
return verb, args
|
||||
}
|
||||
|
||||
func (b *Bot) command(ctx context.Context, m incoming) bool {
|
||||
verb, args := splitCommand(m.text)
|
||||
if verb == "move" || verb == "migrate" {
|
||||
return b.moveCommand(ctx, m, cmp.Or(m.threadTS, m.ts))
|
||||
}
|
||||
reply, ok := b.runCommand(ctx, m, verb, args, false)
|
||||
if reply != "" {
|
||||
b.say(ctx, m.channel, m.threadTS, reply)
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// runCommand returns ok=false when the text isn't a command, so it belongs to
|
||||
// the agent. An empty reply means it was posted already, with buttons. The
|
||||
// agent can't press buttons, so it gets plain text instead.
|
||||
func (b *Bot) runCommand(ctx context.Context, m incoming, verb, args string, agent bool) (reply string, ok bool) {
|
||||
ownerID, kind := m.owner()
|
||||
if verb == "grant" || verb == "revoke" || verb == "dm" || verb == "managers" || (verb == "permissions" && args != "") {
|
||||
return b.manageCommand(ctx, m, verb, args)
|
||||
}
|
||||
if need := commands.NeededPermission(verb, args); need != "" && !b.permitted(ctx, m.channel, m.threadTS, m.user, kind, need) {
|
||||
return true
|
||||
if commands.IsListen(verb) {
|
||||
c, err := commands.ParseListen(args)
|
||||
if err != nil {
|
||||
return "", false
|
||||
}
|
||||
return b.listenReply(m, c), true
|
||||
}
|
||||
if need := commands.NeededPermission(verb, args); need != "" {
|
||||
if denied := b.denial(ctx, m.channel, m.user, kind, need); denied != "" {
|
||||
return denied, true
|
||||
}
|
||||
}
|
||||
if verb == "stop" || verb == "scale" || verb == "storage" || verb == "disk" {
|
||||
if b.blocked(ctx, m.channel, m.threadTS, ownerID) {
|
||||
return true
|
||||
if reply, ok := b.blocked(ctx, m.channel, ownerID, agent); ok {
|
||||
return reply, true
|
||||
}
|
||||
}
|
||||
|
||||
reply := ""
|
||||
switch {
|
||||
case verb == "" || verb == "help" && args == "":
|
||||
reply = helpText
|
||||
@@ -375,34 +404,27 @@ func (b *Bot) command(ctx context.Context, m incoming) bool {
|
||||
case verb == "sessions" && args == "":
|
||||
reply = b.sessionList(ctx, ownerID)
|
||||
case verb == "status" && args == "":
|
||||
if agent {
|
||||
return b.statusText(ctx, ownerID, kind), true
|
||||
}
|
||||
b.postStatus(ctx, m.channel, m.threadTS, ownerID, kind)
|
||||
return true
|
||||
return "", true
|
||||
case verb == "stop" && args == "":
|
||||
reply = b.stopFor(ctx, ownerID)
|
||||
case verb == "scale":
|
||||
var ok bool
|
||||
if reply, ok = b.scaleFor(ctx, ownerID, kind, args); !ok {
|
||||
return false
|
||||
}
|
||||
return b.scaleFor(ctx, ownerID, kind, args)
|
||||
case verb == "keep":
|
||||
var ok bool
|
||||
if reply, ok = b.keepFor(ownerID, kind, args); !ok {
|
||||
return false
|
||||
}
|
||||
return b.keepFor(ownerID, kind, args)
|
||||
case verb == "nodes" && args == "":
|
||||
reply = b.nodesList(ctx, ownerID)
|
||||
case verb == "permissions" && args == "":
|
||||
reply = b.permissionsList(ctx, m.channel, kind)
|
||||
case verb == "storage" || verb == "disk":
|
||||
var ok bool
|
||||
if reply, ok = b.storageFor(ctx, ownerID, kind, args); !ok {
|
||||
return false
|
||||
}
|
||||
return b.storageFor(ctx, ownerID, kind, args)
|
||||
default:
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
b.say(ctx, m.channel, m.threadTS, reply)
|
||||
return true
|
||||
return reply, true
|
||||
}
|
||||
|
||||
func (b *Bot) onAction(ctx context.Context, cb slack.InteractionCallback) {
|
||||
@@ -446,6 +468,11 @@ func (b *Bot) onAction(ctx context.Context, cb slack.InteractionCallback) {
|
||||
b.waiting[u.Node][cb.Channel.ID] = true
|
||||
b.waitMu.Unlock()
|
||||
b.say(ctx, cb.Channel.ID, thread, fmt.Sprintf("OK, waiting for %s. I'll post here when it's back up.", u.Node))
|
||||
case "restart":
|
||||
b.restartFor(ctx, cb, ownerID, kind)
|
||||
case "later":
|
||||
b.settlePrompt(ctx, cb, "OK, not now. The update applies the next time the container starts, "+
|
||||
"for example after `stop` and a new message.")
|
||||
case "stop", "scale":
|
||||
if b.mgr.State(u) == manager.StateOffline {
|
||||
b.deadSlave(ctx, cb.Channel.ID, "", ownerID, u.Node)
|
||||
@@ -479,7 +506,7 @@ func (b *Bot) sessionList(ctx context.Context, ownerID string) string {
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func (b *Bot) postStatus(ctx context.Context, channel, thread, ownerID string, kind model.OwnerKind) {
|
||||
func (b *Bot) statusText(ctx context.Context, ownerID string, kind model.OwnerKind) string {
|
||||
u := b.store.Owner(ownerID)
|
||||
state := b.mgr.State(u)
|
||||
size := b.cfg.Container
|
||||
@@ -512,8 +539,17 @@ func (b *Bot) postStatus(ctx context.Context, channel, thread, ownerID string, k
|
||||
for _, name := range b.mgr.OfflineNodes() {
|
||||
fmt.Fprintf(&sb, "\n• %s: offline", name)
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
text := sb.String()
|
||||
func (b *Bot) postStatus(ctx context.Context, channel, thread, ownerID string, kind model.OwnerKind) {
|
||||
u := b.store.Owner(ownerID)
|
||||
state := b.mgr.State(u)
|
||||
size := b.cfg.Container
|
||||
if u != nil {
|
||||
size = u.Size
|
||||
}
|
||||
text := b.statusText(ctx, ownerID, kind)
|
||||
blocks := []slack.Block{slack.NewSectionBlock(slack.NewTextBlockObject(slack.MarkdownType, text, false, false), nil, nil)}
|
||||
|
||||
var buttons []slack.BlockElement
|
||||
@@ -712,26 +748,34 @@ func (b *Bot) moveTarget(args string) (target string, ok bool) {
|
||||
}
|
||||
|
||||
func (b *Bot) permitted(ctx context.Context, channel, thread, user string, kind model.OwnerKind, a model.Action) bool {
|
||||
p := b.store.Permissions()
|
||||
if p.Allowed(kind, channel, user, a) {
|
||||
text := b.denial(ctx, channel, user, kind, a)
|
||||
if text == "" {
|
||||
return true
|
||||
}
|
||||
var text string
|
||||
if kind == model.OwnerUser {
|
||||
text = fmt.Sprintf(":lock: Changing *%s* from DMs is turned off on this server.", a)
|
||||
} else if holders := p.Holders(channel, a); len(holders) == 0 {
|
||||
text = fmt.Sprintf(":lock: Nobody here has *%s* permission. An admin can grant it in the config.", a)
|
||||
} else {
|
||||
names := make([]string, len(holders))
|
||||
for i, h := range holders {
|
||||
names[i] = b.displayName(ctx, h)
|
||||
}
|
||||
text = fmt.Sprintf(":lock: Only super users with *%s* permission can do that here: %s.", a, strings.Join(names, ", "))
|
||||
}
|
||||
b.say(ctx, channel, thread, text)
|
||||
return false
|
||||
}
|
||||
|
||||
// denial explains why the user may not do a, or is empty when they may.
|
||||
func (b *Bot) denial(ctx context.Context, channel, user string, kind model.OwnerKind, a model.Action) string {
|
||||
p := b.store.Permissions()
|
||||
if p.Allowed(kind, channel, user, a) {
|
||||
return ""
|
||||
}
|
||||
if kind == model.OwnerUser {
|
||||
return fmt.Sprintf(":lock: Changing *%s* from DMs is turned off on this server.", a)
|
||||
}
|
||||
holders := p.Holders(channel, a)
|
||||
if len(holders) == 0 {
|
||||
return fmt.Sprintf(":lock: Nobody here has *%s* permission. An admin can grant it in the config.", a)
|
||||
}
|
||||
names := make([]string, len(holders))
|
||||
for i, h := range holders {
|
||||
names[i] = b.displayName(ctx, h)
|
||||
}
|
||||
return fmt.Sprintf(":lock: Only super users with *%s* permission can do that here: %s.", a, strings.Join(names, ", "))
|
||||
}
|
||||
|
||||
func (b *Bot) permissionsList(ctx context.Context, channel string, kind model.OwnerKind) string {
|
||||
p := b.store.Permissions()
|
||||
if kind == model.OwnerUser {
|
||||
@@ -775,37 +819,54 @@ func (b *Bot) permissionsList(ctx context.Context, channel string, kind model.Ow
|
||||
return strings.Join(lines, "\n")
|
||||
}
|
||||
|
||||
func (b *Bot) blocked(ctx context.Context, channel, thread, ownerID string) bool {
|
||||
// blocked explains why the container can't be changed right now. In Slack a
|
||||
// dead node gets its recreate/wait buttons instead, and the reply is empty.
|
||||
func (b *Bot) blocked(ctx context.Context, channel, ownerID string, agent bool) (reply string, ok bool) {
|
||||
if b.mgr.IsMigrating(ownerID) {
|
||||
b.say(ctx, channel, thread, b.explain(manager.ErrMigrating))
|
||||
return true
|
||||
return b.explain(manager.ErrMigrating), true
|
||||
}
|
||||
if u := b.store.Owner(ownerID); b.mgr.State(u) == manager.StateOffline {
|
||||
if agent {
|
||||
return fmt.Sprintf("Node %s is offline right now.", u.Node), true
|
||||
}
|
||||
b.deadSlave(ctx, channel, "", ownerID, u.Node)
|
||||
return true
|
||||
return "", true
|
||||
}
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
|
||||
func (b *Bot) moveCommand(ctx context.Context, m incoming, replyThread string) bool {
|
||||
verb, args, _ := strings.Cut(strings.TrimSpace(m.text), " ")
|
||||
verb = strings.ToLower(strings.TrimRight(verb, ".!?"))
|
||||
verb, args := splitCommand(m.text)
|
||||
if verb != "move" && verb != "migrate" {
|
||||
return false
|
||||
}
|
||||
target, ok := b.moveTarget(strings.TrimRight(strings.TrimSpace(args), " .!?"))
|
||||
reply, ok := b.move(ctx, m, args, replyThread, false)
|
||||
if reply != "" {
|
||||
b.say(ctx, m.channel, replyThread, reply)
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
func (b *Bot) move(ctx context.Context, m incoming, args, replyThread string, agent bool) (reply string, ok bool) {
|
||||
target, ok := b.moveTarget(args)
|
||||
if !ok {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
ownerID, kind := m.owner()
|
||||
if !b.permitted(ctx, m.channel, replyThread, m.user, kind, model.ActMove) {
|
||||
return true
|
||||
if denied := b.denial(ctx, m.channel, m.user, kind, model.ActMove); denied != "" {
|
||||
return denied, true
|
||||
}
|
||||
if b.blocked(ctx, m.channel, replyThread, ownerID) {
|
||||
return true
|
||||
if reply, ok := b.blocked(ctx, m.channel, ownerID, agent); ok {
|
||||
return reply, true
|
||||
}
|
||||
go b.moveFor(ctx, m.channel, ownerID, target, "<@"+m.user+">", replyThread)
|
||||
return true
|
||||
trigger := "<@" + m.user + ">"
|
||||
if !agent {
|
||||
go b.moveFor(ctx, m.channel, ownerID, target, trigger, replyThread)
|
||||
return "", true
|
||||
}
|
||||
go b.moveFor(ctx, m.channel, ownerID, target, "the agent, for "+trigger, replyThread)
|
||||
return "The move has started, and its progress is posted in Slack. The container is stopped briefly near the end, " +
|
||||
"so finish your reply now. The user can carry on in this thread once it's done.", true
|
||||
}
|
||||
|
||||
func (b *Bot) moveFor(ctx context.Context, channel, ownerID, target, trigger, replyThread string) {
|
||||
|
||||
@@ -32,14 +32,11 @@ func actionList(actions []model.Action) string {
|
||||
|
||||
// manageCommand handles permission changes. It returns false if the message
|
||||
// isn't one of these commands, so it goes to the agent.
|
||||
func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string) bool {
|
||||
func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string) (string, bool) {
|
||||
_, kind := m.owner()
|
||||
p := b.store.Permissions()
|
||||
reply := func(text string) bool {
|
||||
b.say(ctx, m.channel, m.threadTS, text)
|
||||
return true
|
||||
}
|
||||
denied := func(global bool) bool {
|
||||
reply := func(text string) (string, bool) { return text, true }
|
||||
denied := func(global bool) (string, bool) {
|
||||
who := "user managers"
|
||||
if !global {
|
||||
who = "user managers and people with *manage* permission here"
|
||||
@@ -58,7 +55,7 @@ func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string)
|
||||
case "grant", "revoke":
|
||||
g, err := commands.ParseGrant(args)
|
||||
if errors.Is(err, commands.ErrNotCommand) {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
if err != nil {
|
||||
return reply(":warning: " + err.Error() + ". Try `grant @alice move scale` or `revoke @alice`.")
|
||||
@@ -119,11 +116,11 @@ func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string)
|
||||
case "dm":
|
||||
words := strings.Fields(strings.ToLower(args))
|
||||
if len(words) != 2 || !slices.Contains(model.AllActions, model.Action(words[0])) {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
on, ok := commands.ParseToggle(words[1])
|
||||
if !ok {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
if !p.IsManager(m.user) {
|
||||
return denied(true)
|
||||
@@ -145,7 +142,7 @@ func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string)
|
||||
op := strings.ToLower(words[0])
|
||||
g, err := commands.ParseGrant(strings.Join(words[1:], " "))
|
||||
if (op != "add" && op != "remove") || err != nil || len(g.Actions) > 0 {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
if !p.IsManager(m.user) {
|
||||
return denied(true)
|
||||
@@ -171,7 +168,7 @@ func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string)
|
||||
|
||||
case "permissions":
|
||||
if strings.ToLower(args) != "reset" {
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
if kind == model.OwnerUser {
|
||||
return reply("DMs don't have a super-user list to reset.")
|
||||
@@ -184,5 +181,5 @@ func (b *Bot) manageCommand(ctx context.Context, m incoming, verb, args string)
|
||||
}
|
||||
return reply("Done. This channel uses the default super-user list again.")
|
||||
}
|
||||
return false
|
||||
return "", false
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package bot
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
|
||||
"github.com/slack-go/slack"
|
||||
|
||||
"slackerbot/internal/manager"
|
||||
"slackerbot/internal/model"
|
||||
)
|
||||
|
||||
const updateText = ":arrows_counterclockwise: A system update is waiting for this container. " +
|
||||
"Restarting applies it. Files in /root and your sessions are kept."
|
||||
|
||||
// offerUpdate asks once per container whether to restart onto the node's
|
||||
// current system. Asking again needs a newer system or a bot restart.
|
||||
func (b *Bot) offerUpdate(ctx context.Context, u *model.Owner, channel, thread string) {
|
||||
if !b.mgr.Outdated(ctx, u) {
|
||||
b.updateAsked.Delete(u.Machine)
|
||||
return
|
||||
}
|
||||
if _, asked := b.updateAsked.LoadOrStore(u.Machine, true); asked {
|
||||
return
|
||||
}
|
||||
restart := slack.NewButtonBlockElement("restart", u.ID, slack.NewTextBlockObject(slack.PlainTextType, "Restart now", false, false))
|
||||
restart.Style = slack.StylePrimary
|
||||
later := slack.NewButtonBlockElement("later", u.ID, slack.NewTextBlockObject(slack.PlainTextType, "Later", false, false))
|
||||
blocks := []slack.Block{
|
||||
slack.NewSectionBlock(slack.NewTextBlockObject(slack.MarkdownType, updateText, false, false), nil, nil),
|
||||
slack.NewActionBlock("update", restart, later),
|
||||
}
|
||||
if _, _, err := b.api.PostMessageContext(ctx, channel, slack.MsgOptionText(updateText, false),
|
||||
slack.MsgOptionBlocks(blocks...), slack.MsgOptionTS(thread)); err != nil {
|
||||
log.Printf("slack post: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// settlePrompt replaces the update prompt, so its buttons can't be pressed twice.
|
||||
func (b *Bot) settlePrompt(ctx context.Context, cb slack.InteractionCallback, text string) {
|
||||
block := slack.NewSectionBlock(slack.NewTextBlockObject(slack.MarkdownType, text, false, false), nil, nil)
|
||||
if _, _, _, err := b.api.UpdateMessageContext(ctx, cb.Channel.ID, cb.Message.Timestamp,
|
||||
slack.MsgOptionText(text, false), slack.MsgOptionBlocks(block)); err != nil {
|
||||
log.Printf("slack update: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Bot) restartFor(ctx context.Context, cb slack.InteractionCallback, ownerID string, kind model.OwnerKind) {
|
||||
channel, thread := cb.Channel.ID, cb.Message.ThreadTimestamp
|
||||
u := b.store.Owner(ownerID)
|
||||
switch b.mgr.State(u) {
|
||||
case manager.StateOffline:
|
||||
b.deadSlave(ctx, channel, "", ownerID, u.Node)
|
||||
return
|
||||
case manager.StateRunning:
|
||||
default:
|
||||
b.settlePrompt(ctx, cb, ":white_check_mark: The container isn't running, so it gets the update when it next starts.")
|
||||
return
|
||||
}
|
||||
if b.isBusy(u.Machine) {
|
||||
b.say(ctx, channel, thread, "The agent is still replying in this container. Press *Restart now* again once it's done.")
|
||||
return
|
||||
}
|
||||
b.settlePrompt(ctx, cb, ":arrows_counterclockwise: Restarting the container to apply the update…")
|
||||
b.currentLifecycle(ctx, u).post(ctx, ":octagonal_sign: Shutting down to apply a system update, asked by <@"+cb.User.ID+">.")
|
||||
b.dropClient(u)
|
||||
|
||||
sl := &startLog{b: b, m: incoming{user: cb.User.ID, channel: channel}, root: thread, ownerID: ownerID}
|
||||
u, err := b.mgr.Restart(ctx, ownerID, kind, func(ev manager.StartEvent) { sl.event(ctx, ev) })
|
||||
if err == nil {
|
||||
_, err = b.client(ctx, u)
|
||||
}
|
||||
if err != nil {
|
||||
sl.failed(ctx, b.explain(err))
|
||||
b.say(ctx, channel, thread, ":warning: The restart didn't finish: "+b.explain(err))
|
||||
return
|
||||
}
|
||||
sl.up(ctx)
|
||||
b.say(ctx, channel, thread, ":white_check_mark: Restarted with the update. Carry on in any thread.")
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package bot
|
||||
|
||||
import (
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/slack-go/slack"
|
||||
|
||||
"slackerbot/internal/acp"
|
||||
"slackerbot/internal/model"
|
||||
"slackerbot/internal/testutil"
|
||||
"slackerbot/internal/testutil/clustertest"
|
||||
)
|
||||
|
||||
func updateBot(t *testing.T) (*Bot, *clustertest.Cluster, *slackLog) {
|
||||
c := clustertest.New(t)
|
||||
c.AddOwner(t, testutil.HomeData(), true)
|
||||
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
||||
srv := httptest.NewServer(log)
|
||||
t.Cleanup(srv.Close)
|
||||
b := &Bot{cfg: c.Cfg, store: c.Store, mgr: c.Mgr, api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/")),
|
||||
acps: map[string]*acp.ACP{}, busy: map[string]int{}}
|
||||
return b, c, log
|
||||
}
|
||||
|
||||
func setOutdated(c *clustertest.Cluster, outdated bool) {
|
||||
c.Master.Mu.Lock()
|
||||
defer c.Master.Mu.Unlock()
|
||||
c.Master.Outdated["c-c1"] = outdated
|
||||
}
|
||||
|
||||
func (s *slackLog) prompts() int {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
n := 0
|
||||
for _, text := range s.text {
|
||||
if strings.Contains(text, "A system update is waiting") {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func TestUpdatePromptOncePerSystem(t *testing.T) {
|
||||
b, c, log := updateBot(t)
|
||||
u := c.Store.Owner("C1")
|
||||
|
||||
b.offerUpdate(c.Ctx, u, "C1", "100.0")
|
||||
if log.prompts() != 0 {
|
||||
t.Fatal("no prompt for a container on the current system")
|
||||
}
|
||||
setOutdated(c, true)
|
||||
b.offerUpdate(c.Ctx, u, "C1", "100.0")
|
||||
b.offerUpdate(c.Ctx, u, "C1", "200.0")
|
||||
if log.prompts() != 1 {
|
||||
t.Fatalf("want one prompt for one pending update, got %d", log.prompts())
|
||||
}
|
||||
setOutdated(c, false)
|
||||
b.offerUpdate(c.Ctx, u, "C1", "100.0")
|
||||
setOutdated(c, true)
|
||||
b.offerUpdate(c.Ctx, u, "C1", "100.0")
|
||||
if log.prompts() != 2 {
|
||||
t.Fatalf("a newer update should be offered again, got %d prompts", log.prompts())
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestartWaitsForReply(t *testing.T) {
|
||||
b, c, log := updateBot(t)
|
||||
setOutdated(c, true)
|
||||
b.setBusy("c-c1", +1)
|
||||
|
||||
cb := slack.InteractionCallback{Channel: slack.Channel{GroupConversation: slack.GroupConversation{
|
||||
Conversation: slack.Conversation{ID: "C1"}}}}
|
||||
cb.Message.Timestamp, cb.Message.ThreadTimestamp = "5.0", "100.0"
|
||||
b.restartFor(c.Ctx, cb, "C1", model.OwnerChannel)
|
||||
|
||||
c.Master.Mu.Lock()
|
||||
still := c.Master.Outdated["c-c1"]
|
||||
c.Master.Mu.Unlock()
|
||||
if !still {
|
||||
t.Fatal("a busy container must not be restarted")
|
||||
}
|
||||
log.mu.Lock()
|
||||
defer log.mu.Unlock()
|
||||
for _, text := range log.text {
|
||||
if strings.Contains(text, "still replying") {
|
||||
return
|
||||
}
|
||||
}
|
||||
t.Fatal("the user should be told to try again once the reply is done")
|
||||
}
|
||||
@@ -29,6 +29,9 @@ const (
|
||||
machinedName = "org.freedesktop.machine1"
|
||||
machinedPath = "/org/freedesktop/machine1"
|
||||
machinedMgr = "org.freedesktop.machine1.Manager"
|
||||
systemdName = "org.freedesktop.systemd1"
|
||||
systemdPath = "/org/freedesktop/systemd1"
|
||||
systemdMgr = "org.freedesktop.systemd1.Manager"
|
||||
sigPoweroff = 38 // SIGRTMIN+4, what `machinectl poweroff` sends
|
||||
|
||||
agentEnvInside = "/var/lib/slackerbot/agent.env"
|
||||
@@ -114,7 +117,7 @@ func (l *Local) Running(ctx context.Context) ([]node.RunningMachine, error) {
|
||||
if !model.IsOurs(x.Name) {
|
||||
continue
|
||||
}
|
||||
r := node.RunningMachine{Name: x.Name}
|
||||
r := node.RunningMachine{Name: x.Name, Outdated: l.outdated(x.Name)}
|
||||
if v, err := l.bus.Object(machinedName, x.Path).GetProperty("org.freedesktop.machine1.Machine.Timestamp"); err == nil {
|
||||
if us, ok := v.Value().(uint64); ok {
|
||||
r.Since = time.UnixMicro(int64(us))
|
||||
@@ -125,6 +128,40 @@ func (l *Local) Running(ctx context.Context) ([]node.RunningMachine, error) {
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// The unit's command ends with the init of the system the container booted.
|
||||
// When it can't be read, the container counts as up to date.
|
||||
func (l *Local) outdated(machine string) bool {
|
||||
args := l.execStart(unitName(machine))
|
||||
if len(args) == 0 {
|
||||
return false
|
||||
}
|
||||
init := args[len(args)-1]
|
||||
return filepath.Base(init) == "init" && filepath.Dir(init) != l.system
|
||||
}
|
||||
|
||||
func (l *Local) execStart(unit string) []string {
|
||||
var path dbus.ObjectPath
|
||||
if err := l.bus.Object(systemdName, systemdPath).Call(systemdMgr+".GetUnit", 0, unit).Store(&path); err != nil {
|
||||
return nil
|
||||
}
|
||||
v, err := l.bus.Object(systemdName, path).GetProperty(systemdName + ".Service.ExecStart")
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
var cmds []struct {
|
||||
Path string
|
||||
Args []string
|
||||
IgnoreErrors bool
|
||||
StartTime, StartTimeMono, ExitTime, ExitTimeMono uint64
|
||||
PID uint32
|
||||
Code, Status int32
|
||||
}
|
||||
if err := v.Store(&cmds); err != nil || len(cmds) == 0 {
|
||||
return nil
|
||||
}
|
||||
return cmds[0].Args
|
||||
}
|
||||
|
||||
func (l *Local) IsRunning(machine string) bool {
|
||||
var p dbus.ObjectPath
|
||||
return l.machined().Call(machinedMgr+".GetMachine", 0, machine).Store(&p) == nil
|
||||
@@ -201,16 +238,25 @@ func (l *Local) Start(ctx context.Context, spec node.StartSpec) error {
|
||||
"--bind-ro=" + envFile + ":" + agentEnvInside,
|
||||
"--bind=" + home + ":/root",
|
||||
}
|
||||
for _, b := range l.cfg.ROBinds {
|
||||
args = append(args, "--bind-ro="+strings.ReplaceAll(b, "{machine}", spec.Machine))
|
||||
}
|
||||
for _, b := range l.cfg.RWBinds {
|
||||
b = strings.ReplaceAll(b, "{machine}", spec.Machine)
|
||||
src, _, _ := strings.Cut(b, ":")
|
||||
if err := os.MkdirAll(src, 0o755); err != nil {
|
||||
return err
|
||||
binds := func(list []string, flag string) error {
|
||||
for _, b := range list {
|
||||
b = strings.ReplaceAll(b, "{machine}", spec.Machine)
|
||||
src, _, _ := strings.Cut(b, ":")
|
||||
// Missing sources make systemd-nspawn fail; existing ones may be files.
|
||||
if _, err := os.Stat(src); errors.Is(err, os.ErrNotExist) {
|
||||
if err := os.MkdirAll(src, 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
args = append(args, flag+b)
|
||||
}
|
||||
args = append(args, "--bind="+b)
|
||||
return nil
|
||||
}
|
||||
if err := binds(l.cfg.ROBinds, "--bind-ro="); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := binds(l.cfg.RWBinds, "--bind="); err != nil {
|
||||
return err
|
||||
}
|
||||
args = append(args, filepath.Join(l.system, "init"))
|
||||
|
||||
|
||||
@@ -28,6 +28,7 @@ go_test(
|
||||
"cluster_test.go",
|
||||
"files_test.go",
|
||||
"migrate_test.go",
|
||||
"update_test.go",
|
||||
],
|
||||
embed = [":manager"],
|
||||
deps = [
|
||||
|
||||
@@ -248,6 +248,50 @@ func (m *Manager) EnsureProgress(ctx context.Context, id string, kind model.Owne
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// Restart stops a running container and starts it again, so it boots the
|
||||
// node's current system.
|
||||
func (m *Manager) Restart(ctx context.Context, id string, kind model.OwnerKind, progress func(StartEvent)) (*model.Owner, error) {
|
||||
if m.IsMigrating(id) {
|
||||
return nil, ErrMigrating
|
||||
}
|
||||
unlock := m.ownerMu.Lock(id)
|
||||
u, err := m.ownerRecord(id, kind)
|
||||
if err == nil && u.Node != "" {
|
||||
var n node.Node
|
||||
if n, err = m.nodeByName(u.Node); err == nil && n.IsRunning(u.Machine) {
|
||||
log.Printf("container: restarting %s for %s %s on %s", u.Machine, u.Kind, u.ID, u.Node)
|
||||
if err = n.Poweroff(ctx, u.Machine); err == nil {
|
||||
err = n.WaitStopped(ctx, u.Machine)
|
||||
}
|
||||
}
|
||||
}
|
||||
unlock()
|
||||
if err != nil {
|
||||
return u, err
|
||||
}
|
||||
return m.EnsureProgress(ctx, id, kind, progress)
|
||||
}
|
||||
|
||||
func (m *Manager) Outdated(ctx context.Context, u *model.Owner) bool {
|
||||
if u == nil || u.Node == "" {
|
||||
return false
|
||||
}
|
||||
n, err := m.nodeByName(u.Node)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
running, err := n.Running(ctx)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
for _, r := range running {
|
||||
if r.Name == u.Machine {
|
||||
return r.Outdated
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// The old home folder stays on its node, untouched.
|
||||
func (m *Manager) Recreate(id string) error {
|
||||
if m.IsMigrating(id) {
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
package manager_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"slackerbot/internal/model"
|
||||
"slackerbot/internal/testutil"
|
||||
"slackerbot/internal/testutil/clustertest"
|
||||
)
|
||||
|
||||
func TestRestartAppliesUpdate(t *testing.T) {
|
||||
c := clustertest.New(t)
|
||||
c.AddOwner(t, testutil.HomeData(), true)
|
||||
u := c.Store.Owner("C1")
|
||||
if c.Mgr.Outdated(c.Ctx, u) {
|
||||
t.Fatal("a container on the current system isn't outdated")
|
||||
}
|
||||
|
||||
c.Master.Mu.Lock()
|
||||
c.Master.Outdated["c-c1"] = true
|
||||
c.Master.Mu.Unlock()
|
||||
if !c.Mgr.Outdated(c.Ctx, u) {
|
||||
t.Fatal("the node said the container is outdated")
|
||||
}
|
||||
|
||||
if _, err := c.Mgr.Restart(c.Ctx, "C1", model.OwnerChannel, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !c.Master.IsRunning("c-c1") || c.Mgr.Outdated(c.Ctx, u) {
|
||||
t.Fatal("after a restart the container should run the current system")
|
||||
}
|
||||
if c.Master.Last.Machine != "c-c1" {
|
||||
t.Fatal("the container wasn't started again")
|
||||
}
|
||||
}
|
||||
|
||||
func TestOutdatedThroughSlave(t *testing.T) {
|
||||
c := clustertest.New(t)
|
||||
u := &model.Owner{ID: "C2", Kind: model.OwnerChannel, Machine: "c-c2", Node: "slave-1", Drive: "/d"}
|
||||
c.Slave.Mu.Lock()
|
||||
c.Slave.Runs["c-c2"], c.Slave.Outdated["c-c2"] = true, true
|
||||
c.Slave.Mu.Unlock()
|
||||
testutil.WaitFor(t, "slave to report the outdated container", func() bool { return c.Mgr.Outdated(c.Ctx, u) })
|
||||
}
|
||||
|
||||
func TestRestartStoppedContainerJustStarts(t *testing.T) {
|
||||
c := clustertest.New(t)
|
||||
c.AddOwner(t, testutil.HomeData(), false)
|
||||
if _, err := c.Mgr.Restart(c.Ctx, "C1", model.OwnerChannel, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !c.Master.IsRunning("c-c1") {
|
||||
t.Fatal("a stopped container should just start")
|
||||
}
|
||||
}
|
||||
@@ -61,6 +61,8 @@ type DriveInfo struct {
|
||||
type RunningMachine struct {
|
||||
Name string `json:"name"`
|
||||
Since time.Time `json:"since"`
|
||||
// Booted an older system than the node has now.
|
||||
Outdated bool `json:"outdated,omitempty"`
|
||||
}
|
||||
|
||||
type StartSpec struct {
|
||||
|
||||
@@ -19,6 +19,7 @@ type FakeNode struct {
|
||||
name string
|
||||
Mu sync.Mutex
|
||||
Runs map[string]bool
|
||||
Outdated map[string]bool // machines that booted an older system; cleared on Start
|
||||
Last node.StartSpec
|
||||
Homes map[string][]byte
|
||||
Files map[string][]byte
|
||||
@@ -31,7 +32,7 @@ type FakeNode struct {
|
||||
}
|
||||
|
||||
func NewFakeNode(name string) *FakeNode {
|
||||
return &FakeNode{name: name, Runs: map[string]bool{}, Homes: map[string][]byte{}, Files: map[string][]byte{},
|
||||
return &FakeNode{name: name, Runs: map[string]bool{}, Outdated: map[string]bool{}, Homes: map[string][]byte{}, Files: map[string][]byte{},
|
||||
Exports: map[string]*fakeExport{}, Imports: map[string]*fakeImport{}, Usable: model.Size{MemoryMB: 8192, CPUs: 4}}
|
||||
}
|
||||
|
||||
@@ -52,7 +53,7 @@ func (f *FakeNode) Running(context.Context) ([]node.RunningMachine, error) {
|
||||
defer f.Mu.Unlock()
|
||||
var out []node.RunningMachine
|
||||
for m := range f.Runs {
|
||||
out = append(out, node.RunningMachine{Name: m})
|
||||
out = append(out, node.RunningMachine{Name: m, Outdated: f.Outdated[m]})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
@@ -65,6 +66,7 @@ func (f *FakeNode) Start(_ context.Context, spec node.StartSpec) error {
|
||||
f.Mu.Lock()
|
||||
defer f.Mu.Unlock()
|
||||
f.Last, f.Runs[spec.Machine] = spec, true
|
||||
delete(f.Outdated, spec.Machine)
|
||||
return nil
|
||||
}
|
||||
func (f *FakeNode) Poweroff(_ context.Context, machine string) error {
|
||||
|
||||
@@ -3,17 +3,22 @@ load("@rules_go//go:def.bzl", "go_library", "go_test")
|
||||
go_library(
|
||||
name = "tools",
|
||||
srcs = [
|
||||
"commands.go",
|
||||
"server.go",
|
||||
"session.go",
|
||||
],
|
||||
importpath = "slackerbot/internal/tools",
|
||||
visibility = ["//slackerbot:__subpackages__"],
|
||||
deps = ["//slackerbot/internal/acp"],
|
||||
deps = [
|
||||
"//slackerbot/internal/acp",
|
||||
"//slackerbot/internal/util",
|
||||
],
|
||||
)
|
||||
|
||||
go_test(
|
||||
name = "tools_test",
|
||||
srcs = [
|
||||
"commands_test.go",
|
||||
"server_test.go",
|
||||
"session_test.go",
|
||||
],
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"slackerbot/internal/acp"
|
||||
"slackerbot/internal/util"
|
||||
)
|
||||
|
||||
// SlackCommand is a Slack command offered to the agent as a tool. Its text is Verb
|
||||
// followed by the call's args, exactly as a user would type it.
|
||||
type SlackCommand struct {
|
||||
Name string
|
||||
Verb string
|
||||
Help string
|
||||
// Describes the args parameter. Empty when the command takes none.
|
||||
Args string
|
||||
Required bool
|
||||
// With no args it only shows a setting.
|
||||
Shows bool
|
||||
}
|
||||
|
||||
const (
|
||||
Stop = "stop"
|
||||
Move = "move"
|
||||
)
|
||||
|
||||
var Commands = []SlackCommand{
|
||||
{Name: "status", Verb: "status", Shows: true,
|
||||
Help: "Show this container's state, size, node, time unused, idle limit, home folder usage and every node."},
|
||||
{Name: "sessions", Verb: "sessions", Shows: true,
|
||||
Help: "List this container's recent sessions (Slack threads), with links."},
|
||||
{Name: "nodes", Verb: "nodes", Shows: true,
|
||||
Help: "List every node with the CPU, RAM and storage free on it, and where this container runs."},
|
||||
{Name: "permissions", Verb: "permissions", Shows: true,
|
||||
Help: "Show who may scale, change storage, move or set the idle limit here, and who the user managers are."},
|
||||
{Name: Stop, Verb: "stop",
|
||||
Help: "Shut this container down once your current reply is finished. The home folder is kept, and the next message starts it again."},
|
||||
{Name: "scale", Verb: "scale", Required: true,
|
||||
Help: "Change this container's RAM and CPU. A running container changes right away; shrinking memory may stop programs.",
|
||||
Args: "`up` or `down` to double or halve, an exact size like `8G 4cpu`, or a change like `+2G` or `-1cpu`"},
|
||||
{Name: "keep", Verb: "keep", Shows: true,
|
||||
Help: "Show or set how long this container may sit unused before it's stopped.",
|
||||
Args: "A time like `24h`, `3d` or `2w`, `indefinite` to never stop it, or `default` to reset. Empty shows the current limit"},
|
||||
{Name: "storage", Verb: "storage", Shows: true,
|
||||
Help: "Show the home folder's usage, or change its guaranteed space and max size.",
|
||||
Args: "A new max like `20G`, a change like `+5G`, or `min 8G` / `min 8G max 20G`. Empty shows usage"},
|
||||
{Name: Move, Verb: "move",
|
||||
Help: "Move this container to another node. Progress is posted in Slack. Near the end the container is briefly stopped, so finish your reply soon after calling this.",
|
||||
Args: "A node name from `nodes`, or `auto` (or empty) to pick the best one"},
|
||||
{Name: "listen", Verb: "listen", Shows: true,
|
||||
Help: "Show or change which replies in a channel thread reach you. DMs always read every message.",
|
||||
Args: "`all-messages` to read every reply in this thread, `only-mentions` for replies that @mention the bot. Put `channel` first to set the channel's default. Empty shows the setting"},
|
||||
{Name: "grant", Verb: "grant", Required: true,
|
||||
Help: "Give people permissions in this channel. People are Slack mentions like <@U012AB>, as they appear in messages.",
|
||||
Args: "Mentions then permissions (scale, storage, move, keep, manage or all), like `<@U012AB> move scale`. Start with `default` to change the server-wide list"},
|
||||
{Name: "revoke", Verb: "revoke", Required: true,
|
||||
Help: "Take permissions away in this channel. People are Slack mentions like <@U012AB>.",
|
||||
Args: "Mentions, then optionally permissions, like `<@U012AB> move`. Only mentions removes everything. Start with `default` for the server-wide list"},
|
||||
{Name: "reset_permissions", Verb: "permissions reset",
|
||||
Help: "Make this channel use the server-wide default list of super users again."},
|
||||
{Name: "dm_permission", Verb: "dm", Required: true,
|
||||
Help: "Allow or forbid everyone changing a setting on their own DM container. User managers only.",
|
||||
Args: "A permission and on or off, like `storage off`"},
|
||||
{Name: "managers", Verb: "managers", Shows: true,
|
||||
Help: "Show, add or remove user managers.",
|
||||
Args: "`add <@U012AB>` or `remove <@U012AB>`. Empty lists them"},
|
||||
}
|
||||
|
||||
func commandNamed(name string) (SlackCommand, bool) {
|
||||
for _, c := range Commands {
|
||||
if c.Name == name {
|
||||
return c, true
|
||||
}
|
||||
}
|
||||
return SlackCommand{}, false
|
||||
}
|
||||
|
||||
func (c SlackCommand) Text(args string) string {
|
||||
return strings.TrimSpace(c.Verb + " " + strings.TrimSpace(args))
|
||||
}
|
||||
|
||||
// Missing calls are refused by the server, so the bot doesn't run them.
|
||||
func (c SlackCommand) Missing(args string) bool {
|
||||
return c.Required && strings.TrimSpace(args) == ""
|
||||
}
|
||||
|
||||
func (c SlackCommand) Changes(args string) bool {
|
||||
return !c.Shows || strings.TrimSpace(args) != ""
|
||||
}
|
||||
|
||||
// Reply is what the bot answers a command call with.
|
||||
type Reply struct {
|
||||
Text string `json:"text"`
|
||||
Error bool `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
// The MCP server can't reach the bot, so the bot runs the command when it
|
||||
// sees the call over ACP and drops the reply here for the server to pick up.
|
||||
// The server only knows the tool and its args, so they name the file.
|
||||
func replyDir(home string) string { return filepath.Join(home, ".slackerbot", "replies") }
|
||||
|
||||
func replyPrefix(name, args string) string {
|
||||
sum := sha256.Sum256([]byte(name + "\x00" + strings.TrimSpace(args)))
|
||||
return hex.EncodeToString(sum[:8]) + "-"
|
||||
}
|
||||
|
||||
func ReplyPath(home, name, args string) string {
|
||||
return filepath.Join(replyDir(home), replyPrefix(name, args)+util.RandomHex(6)+".json")
|
||||
}
|
||||
|
||||
func argsOf(raw json.RawMessage) string {
|
||||
var in struct {
|
||||
Args string `json:"args"`
|
||||
}
|
||||
_ = json.Unmarshal(raw, &in)
|
||||
return in.Args
|
||||
}
|
||||
|
||||
// toolName is the slackerbot tool an ACP tool call is for. Goose names it in
|
||||
// _meta, and older versions only in the title ("slackerbot: send file · …").
|
||||
func toolName(u acp.Update) (string, bool) {
|
||||
if name, ok := strings.CutPrefix(u.ToolName, ServerName+"__"); ok {
|
||||
return name, true
|
||||
}
|
||||
best := ""
|
||||
for _, name := range append([]string{SendFile}, commandNames()...) {
|
||||
t := ServerName + ": " + strings.ReplaceAll(name, "_", " ")
|
||||
if (u.Title == t || strings.HasPrefix(u.Title, t+" ")) && len(name) > len(best) {
|
||||
best = name
|
||||
}
|
||||
}
|
||||
return best, best != ""
|
||||
}
|
||||
|
||||
func commandNames() []string {
|
||||
names := make([]string, len(Commands))
|
||||
for i, c := range Commands {
|
||||
names[i] = c.Name
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
// CommandCall reports whether an ACP update starts a command tool call, and with which args.
|
||||
func CommandCall(u acp.Update) (c SlackCommand, args string, ok bool) {
|
||||
if u.Kind != "tool_call" {
|
||||
return SlackCommand{}, "", false
|
||||
}
|
||||
name, ok := toolName(u)
|
||||
if !ok {
|
||||
return SlackCommand{}, "", false
|
||||
}
|
||||
c, ok = commandNamed(name)
|
||||
return c, argsOf(u.RawInput), ok
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"io"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"slackerbot/internal/acp"
|
||||
)
|
||||
|
||||
func TestEveryCommandIsListed(t *testing.T) {
|
||||
s := &Server{Home: t.TempDir(), MaxMB: 1}
|
||||
var names []string
|
||||
for _, tool := range s.tools() {
|
||||
names = append(names, tool.(map[string]any)["name"].(string))
|
||||
}
|
||||
for _, want := range []string{"send_file", "status", "sessions", "nodes", "permissions", "stop", "scale", "keep",
|
||||
"storage", "move", "listen", "grant", "revoke", "reset_permissions", "dm_permission", "managers"} {
|
||||
if !strings.Contains(" "+strings.Join(names, " ")+" ", " "+want+" ") {
|
||||
t.Fatalf("%s missing from %v", want, names)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommandWaitsForTheBotsReply(t *testing.T) {
|
||||
home := t.TempDir()
|
||||
s := &Server{Home: home, MaxMB: 1, Wait: 300 * time.Millisecond}
|
||||
os.MkdirAll(replyDir(home), 0o755)
|
||||
old := ReplyPath(home, "keep", "24h")
|
||||
os.WriteFile(old, []byte(`{"text":"stale"}`), 0o644)
|
||||
os.Chtimes(old, time.Now().Add(-time.Hour), time.Now().Add(-time.Hour))
|
||||
|
||||
inR, inW := io.Pipe()
|
||||
var out bytes.Buffer
|
||||
done := make(chan error)
|
||||
go func() { done <- s.Serve(inR, &out) }()
|
||||
inW.Write([]byte(`{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"keep","arguments":{"args":" 24h"}}}` + "\n"))
|
||||
inW.Write([]byte(`{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"scale","arguments":{}}}` + "\n"))
|
||||
inW.Write([]byte(`{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"nodes","arguments":{}}}` + "\n"))
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
data, _ := json.Marshal(Reply{Text: "Done! 24h."})
|
||||
os.WriteFile(ReplyPath(home, "keep", "24h"), data, 0o644)
|
||||
inW.Close()
|
||||
if err := <-done; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
got := map[int]string{}
|
||||
errs := map[int]bool{}
|
||||
for _, line := range strings.Split(strings.TrimSpace(out.String()), "\n") {
|
||||
var r struct {
|
||||
ID int
|
||||
Result struct {
|
||||
Content []struct{ Text string }
|
||||
IsError bool
|
||||
}
|
||||
}
|
||||
_ = json.Unmarshal([]byte(line), &r)
|
||||
got[r.ID], errs[r.ID] = r.Result.Content[0].Text, r.Result.IsError
|
||||
}
|
||||
if got[1] != "Done! 24h." || errs[1] {
|
||||
t.Fatalf("keep: %q", got[1])
|
||||
}
|
||||
if !strings.Contains(got[2], "args is required") || !errs[2] {
|
||||
t.Fatalf("scale without args: %q", got[2])
|
||||
}
|
||||
if !strings.Contains(got[3], "didn't answer in time") || !errs[3] {
|
||||
t.Fatalf("unanswered: %q", got[3])
|
||||
}
|
||||
if left, _ := os.ReadDir(replyDir(home)); len(left) != 0 {
|
||||
t.Fatalf("replies should be cleaned up, left %v", left)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommandCall(t *testing.T) {
|
||||
c, args, ok := CommandCall(acp.Update{Kind: "tool_call", ToolName: "slackerbot__reset_permissions"})
|
||||
if !ok || c.Text(args) != "permissions reset" {
|
||||
t.Fatalf("by tool name: %+v %q %v", c, args, ok)
|
||||
}
|
||||
c, args, ok = CommandCall(acp.Update{Kind: "tool_call", Title: "slackerbot: scale · up", RawInput: json.RawMessage(`{"args":"up"}`)})
|
||||
if !ok || c.Text(args) != "scale up" {
|
||||
t.Fatalf("by title: %+v %q %v", c, args, ok)
|
||||
}
|
||||
if _, _, ok := CommandCall(acp.Update{Kind: "tool_call", ToolName: "slackerbot__send_file"}); ok {
|
||||
t.Fatal("send_file isn't a command")
|
||||
}
|
||||
if _, _, ok := CommandCall(acp.Update{Kind: "tool_call", ToolName: "developer__shell", Title: "status"}); ok {
|
||||
t.Fatal("other servers' tools aren't commands")
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,8 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
@@ -22,9 +24,20 @@ const sendFileHelp = "Send a file to the user in Slack: images, videos, PDFs, ar
|
||||
"It's uploaded into the conversation when your turn ends, so mention it in your reply. " +
|
||||
"At most a few files per turn."
|
||||
|
||||
const commandNote = " It's the same as the Slack command `%s`, and runs with the permissions of the person whose message you're answering."
|
||||
|
||||
const (
|
||||
defaultWait = time.Minute
|
||||
pollEvery = 200 * time.Millisecond
|
||||
// A reply older than this when a call starts belongs to an earlier call that gave up.
|
||||
staleAfter = 30 * time.Second
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
Home string
|
||||
MaxMB int64
|
||||
// How long a command waits for the bot. Zero means a minute.
|
||||
Wait time.Duration
|
||||
}
|
||||
|
||||
type msg struct {
|
||||
@@ -45,20 +58,105 @@ func (s *Server) Serve(in io.Reader, out io.Writer) error {
|
||||
sc := bufio.NewScanner(in)
|
||||
sc.Buffer(make([]byte, 1<<20), 16<<20)
|
||||
enc := json.NewEncoder(out)
|
||||
var mu sync.Mutex
|
||||
var wg sync.WaitGroup
|
||||
defer wg.Wait()
|
||||
write := func(reply msg) error {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
return enc.Encode(reply)
|
||||
}
|
||||
for sc.Scan() {
|
||||
var m msg
|
||||
if json.Unmarshal(sc.Bytes(), &m) != nil || len(m.ID) == 0 {
|
||||
continue
|
||||
}
|
||||
reply := msg{JSONRPC: "2.0", ID: m.ID}
|
||||
// Commands wait on the bot, so they mustn't hold up other requests.
|
||||
if c, args, ok := s.commandCall(m); ok {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
reply.Result = toolResult(s.await(c, args))
|
||||
_ = write(reply)
|
||||
}()
|
||||
continue
|
||||
}
|
||||
reply.Result, reply.Error = s.handle(m)
|
||||
if err := enc.Encode(reply); err != nil {
|
||||
if err := write(reply); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return sc.Err()
|
||||
}
|
||||
|
||||
func toolResult(text string, isErr bool) map[string]any {
|
||||
return map[string]any{"content": []any{map[string]string{"type": "text", "text": text}}, "isError": isErr}
|
||||
}
|
||||
|
||||
func (s *Server) commandCall(m msg) (SlackCommand, string, bool) {
|
||||
if m.Method != "tools/call" {
|
||||
return SlackCommand{}, "", false
|
||||
}
|
||||
var p struct {
|
||||
Name string `json:"name"`
|
||||
Arguments json.RawMessage `json:"arguments"`
|
||||
}
|
||||
_ = json.Unmarshal(m.Params, &p)
|
||||
c, ok := commandNamed(p.Name)
|
||||
return c, argsOf(p.Arguments), ok
|
||||
}
|
||||
|
||||
func (s *Server) await(c SlackCommand, args string) (string, bool) {
|
||||
if c.Missing(args) {
|
||||
return "args is required: " + c.Args, true
|
||||
}
|
||||
wait := s.Wait
|
||||
if wait == 0 {
|
||||
wait = defaultWait
|
||||
}
|
||||
start := time.Now()
|
||||
for {
|
||||
if r, ok := claimReply(replyDir(s.Home), replyPrefix(c.Name, args), start); ok {
|
||||
return r.Text, r.Error
|
||||
}
|
||||
if time.Since(start) > wait {
|
||||
return "slackerbot didn't answer in time, so it may not have run. Its master may be too old for this tool, " +
|
||||
"or the home folder may be full. Ask the user to send the command in Slack instead: " + c.Text(args), true
|
||||
}
|
||||
time.Sleep(pollEvery)
|
||||
}
|
||||
}
|
||||
|
||||
// claimReply takes a reply by deleting it, so two waiting calls can't both get it.
|
||||
// The bot writes a file in one go, so one that doesn't parse yet is still being written.
|
||||
func claimReply(dir, prefix string, since time.Time) (Reply, bool) {
|
||||
entries, _ := os.ReadDir(dir)
|
||||
for _, e := range entries {
|
||||
if !strings.HasPrefix(e.Name(), prefix) {
|
||||
continue
|
||||
}
|
||||
p := filepath.Join(dir, e.Name())
|
||||
info, err := e.Info()
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if info.ModTime().Before(since.Add(-staleAfter)) {
|
||||
_ = os.Remove(p)
|
||||
continue
|
||||
}
|
||||
data, err := os.ReadFile(p)
|
||||
var r Reply
|
||||
if err != nil || json.Unmarshal(data, &r) != nil {
|
||||
continue
|
||||
}
|
||||
if os.Remove(p) == nil {
|
||||
return r, true
|
||||
}
|
||||
}
|
||||
return Reply{}, false
|
||||
}
|
||||
|
||||
func (s *Server) handle(m msg) (any, *rpcError) {
|
||||
switch m.Method {
|
||||
case "initialize":
|
||||
@@ -74,18 +172,7 @@ func (s *Server) handle(m msg) (any, *rpcError) {
|
||||
case "ping":
|
||||
return map[string]any{}, nil
|
||||
case "tools/list":
|
||||
return map[string]any{"tools": []any{map[string]any{
|
||||
"name": SendFile,
|
||||
"description": fmt.Sprintf(sendFileHelp, s.Home, s.MaxMB),
|
||||
"inputSchema": map[string]any{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"path": map[string]string{"type": "string", "description": "Path of the file, e.g. " + s.Home + "/out/chart.png"},
|
||||
"comment": map[string]string{"type": "string", "description": "Optional message posted with the file"},
|
||||
},
|
||||
"required": []string{"path"},
|
||||
},
|
||||
}}}, nil
|
||||
return map[string]any{"tools": s.tools()}, nil
|
||||
case "tools/call":
|
||||
var p struct {
|
||||
Name string `json:"name"`
|
||||
@@ -101,11 +188,45 @@ func (s *Server) handle(m msg) (any, *rpcError) {
|
||||
if err := s.Check(p.Arguments.Path); err != nil {
|
||||
text, isErr = err.Error(), true
|
||||
}
|
||||
return map[string]any{"content": []any{map[string]string{"type": "text", "text": text}}, "isError": isErr}, nil
|
||||
return toolResult(text, isErr), nil
|
||||
}
|
||||
return nil, &rpcError{-32601, "method not found: " + m.Method}
|
||||
}
|
||||
|
||||
func (s *Server) tools() []any {
|
||||
list := []any{map[string]any{
|
||||
"name": SendFile,
|
||||
"description": fmt.Sprintf(sendFileHelp, s.Home, s.MaxMB),
|
||||
"inputSchema": map[string]any{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"path": map[string]string{"type": "string", "description": "Path of the file, e.g. " + s.Home + "/out/chart.png"},
|
||||
"comment": map[string]string{"type": "string", "description": "Optional message posted with the file"},
|
||||
},
|
||||
"required": []string{"path"},
|
||||
},
|
||||
}}
|
||||
for _, c := range Commands {
|
||||
schema := map[string]any{"type": "object", "properties": map[string]any{}}
|
||||
if c.Args != "" {
|
||||
schema["properties"] = map[string]any{"args": map[string]string{"type": "string", "description": c.Args}}
|
||||
}
|
||||
if c.Required {
|
||||
schema["required"] = []string{"args"}
|
||||
}
|
||||
usage := c.Verb
|
||||
if c.Args != "" {
|
||||
usage += " <args>"
|
||||
}
|
||||
list = append(list, map[string]any{
|
||||
"name": c.Name,
|
||||
"description": c.Help + fmt.Sprintf(commandNote, usage),
|
||||
"inputSchema": schema,
|
||||
})
|
||||
}
|
||||
return list
|
||||
}
|
||||
|
||||
func (s *Server) Check(path string) error {
|
||||
if path == "" {
|
||||
return fmt.Errorf("path is required")
|
||||
|
||||
@@ -5,7 +5,6 @@ import (
|
||||
"flag"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"slackerbot/internal/acp"
|
||||
@@ -47,8 +46,8 @@ type Calls struct {
|
||||
}
|
||||
|
||||
func isSendFile(u acp.Update) bool {
|
||||
return u.ToolName == ServerName+"__"+SendFile ||
|
||||
strings.HasPrefix(u.Title, ServerName+": "+strings.ReplaceAll(SendFile, "_", " "))
|
||||
name, ok := toolName(u)
|
||||
return ok && name == SendFile
|
||||
}
|
||||
|
||||
func (c *Calls) Update(u acp.Update) {
|
||||
|
||||
Reference in new issue
Block a user