From 60475274c6c1abea6b62f6bb2732d09f3d6b012b Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Wed, 29 Jul 2026 03:39:52 +1000 Subject: [PATCH] telegram: add dangerous command approval system with /rollback, /stop, /approve, /deny Implement dangerous-command approval UX for Telegram with: - DangerousCommandAuthority interface for sandbox/process control - Inline three-button keyboard: Approve this time, Approve Permanently, Deny - Token-based callbacks: recipient-bound, expiring (10min), single-use, auditable - Command hash prevents callback replay with a changed command - Permanent approval with explicit 24h scope/lifetime and automatic expiry cleanup - /rollback [number]: list checkpoints or request rollback approval - /stop : request process termination approval - /approve and /deny: view pending dangerous commands - 24 tests covering authorization, expiry, replay, denial, execution failure, permanent approval, recipient scoping, and callback parsing Closes: archie-core-alm.6 --- internal/channels/telegram/commands.go | 4 +- internal/channels/telegram/dangerous.go | 561 +++++++++++ internal/channels/telegram/dangerous_test.go | 992 +++++++++++++++++++ internal/channels/telegram/telegram.go | 36 +- internal/channels/telegram/telegram_test.go | 2 +- 5 files changed, 1584 insertions(+), 11 deletions(-) create mode 100644 internal/channels/telegram/dangerous.go create mode 100644 internal/channels/telegram/dangerous_test.go diff --git a/internal/channels/telegram/commands.go b/internal/channels/telegram/commands.go index d00da474c..515c028a6 100644 --- a/internal/channels/telegram/commands.go +++ b/internal/channels/telegram/commands.go @@ -26,11 +26,13 @@ var gatewayCommandSpecs = []commandSpec{ {Command: "model", Description: "Show the model selector or switch directly", Usage: "/model [provider/model]"}, {Command: "spawn", Description: "Create a tracked task", Usage: "/spawn [identity=name] [repo=owner/name] [workflow=name] "}, {Command: "cancel", Description: "Cancel a queued or waiting task", Usage: "/cancel [identity=name] <task-id>"}, + {Command: "rollback", Description: "Restore a filesystem checkpoint", Usage: "/rollback [number]"}, + {Command: "stop", Description: "Terminate a background process", Usage: "/stop <process-name>"}, {Command: "restart", Description: "Reload Archie and its configuration", Usage: "/restart"}, {Command: "help", Description: "See what Archie can do", Usage: "/help"}, } -var telegramOnlyCommands = []string{"provider", "restart", "help", "version", "update"} +var telegramOnlyCommands = []string{"provider", "restart", "help", "version", "update", "rollback", "stop"} var gatewayCommands = func() []models.BotCommand { commands := make([]models.BotCommand, 0, len(gatewayCommandSpecs)) diff --git a/internal/channels/telegram/dangerous.go b/internal/channels/telegram/dangerous.go new file mode 100644 index 000000000..e4977558a --- /dev/null +++ b/internal/channels/telegram/dangerous.go @@ -0,0 +1,561 @@ +package telegram + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "fmt" + "strconv" + "strings" + "time" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" +) + +// DangerousCommandAuthority is the sandbox/process/filesystem authority +// that validates and executes dangerous commands after human approval. +// The daemon's container pool, worktree manager, or similar sandbox owner +// implements this interface. It must not claim control over host +// resources Archie does not own. +type DangerousCommandAuthority interface { + // StopProcess terminates a running background process identified by + // spec (a process name, ID, or other identifier understood by the + // sandbox). Returns an error if the process cannot be found or + // stopped. + StopProcess(ctx context.Context, spec string) error + + // Rollback restores the worktree/sandbox filesystem to a numbered + // checkpoint. Returns a summary of the restored state, or an error + // if the checkpoint does not exist or restoration fails. + Rollback(ctx context.Context, checkpointNumber int) (string, error) + + // ListCheckpoints returns available filesystem checkpoints, newest + // first. Returns an empty slice when no checkpoints exist. + ListCheckpoints(ctx context.Context) ([]CheckpointInfo, error) +} + +// CheckpointInfo describes a saved filesystem checkpoint. +type CheckpointInfo struct { + Number int + Timestamp time.Time + Label string + Size string +} + +// ── dangerous command approval system ───────────────────────────── + +// dangerousCmdPrefix separates dangerous-command callbacks from other +// callback types handled in defaultHandler. +const dangerousCmdPrefix = "dangerous:" + +// dangerousAction records a pending command a human must approve or deny. +// It mirrors the updateAction pattern: random token, recipient-bound, +// expiring, single-use, and carrying a hash so a changed command cannot +// reuse the callback. +type dangerousAction struct { + id string // random token + command string // the full command text + commandHash string // sha256(command) — prevents changed-command replay + description string // human-readable label shown to the approver + recipient int64 // Telegram user who may approve + createdAt time.Time + expiresAt time.Time + // onApprove is the function to call when approved. The Gateway + // supplies this when registering the pending command so the + // authority stays out of the Telegram callback path. + onApprove func(ctx context.Context) (string, error) +} + +// permanentApproval records a decision to approve a category of dangerous +// commands permanently. Scope and lifetime are explicit. +type permanentApproval struct { + // CommandPattern is a prefix match against the command text, e.g. + // "/rollback", "/stop", or a tool name. + CommandPattern string + Recipient int64 + GrantedAt time.Time + ExpiresAt time.Time + // Scope describes the approval boundary for audit purposes. + Scope string +} + +// ── Gateway methods ────────────────────────────────────────────── + +// registerDangerousAction stores a pending command and returns a callback +// token. The caller must present the action to the user (via an inline +// keyboard) immediately after registering. +func (g *Gateway) registerDangerousAction( + command, description string, + recipient int64, + onApprove func(ctx context.Context) (string, error), +) string { + token := makeDangerousToken() + sum := sha256.Sum256([]byte(command)) + hash := hex.EncodeToString(sum[:]) + + g.dangerousMu.Lock() + defer g.dangerousMu.Unlock() + + now := time.Now() + // Expire tokens older than maxPendingAge. + maxPendingAge := 10 * time.Minute + for key, action := range g.dangerousActions { + if !action.expiresAt.After(now) { + delete(g.dangerousActions, key) + } + } + g.dangerousActions[token] = dangerousAction{ + id: token, + command: command, + commandHash: hash, + description: description, + recipient: recipient, + createdAt: now, + expiresAt: now.Add(maxPendingAge), + onApprove: onApprove, + } + return token +} + +// dangerousKeyboard builds the three-button inline keyboard for a +// dangerous command: "Approve this time", "Approve Permanently", "Deny". +func (g *Gateway) dangerousKeyboard(token string) *models.InlineKeyboardMarkup { + return &models.InlineKeyboardMarkup{ + InlineKeyboard: [][]models.InlineKeyboardButton{ + { + { + Text: "Approve this time", + CallbackData: dangerousCmdPrefix + "approve:" + token, + }, + }, + { + { + Text: "Approve Permanently", + CallbackData: dangerousCmdPrefix + "permanent:" + token, + }, + }, + { + { + Text: "Deny", + CallbackData: dangerousCmdPrefix + "deny:" + token, + }, + }, + }, + } +} + +// answerDangerousCallback is the common acknowledge/shake response. +func (g *Gateway) answerDangerousCallback(ctx context.Context, b *bot.Bot, queryID, text string, alert bool) { + if _, err := b.AnswerCallbackQuery(ctx, &bot.AnswerCallbackQueryParams{ + CallbackQueryID: queryID, + Text: text, + ShowAlert: alert, + }); err != nil { + g.log.Warn("answer dangerous callback failed", "error", err) + } +} + +// handleDangerousCallback is the entrypoint for all dangerous-command +// inline-button taps. It validates the token (recipient, expiry, replay, +// hash), records an audit event, and executes or rejects the command. +func (g *Gateway) handleDangerousCallback(ctx context.Context, b *bot.Bot, update *models.Update) { + query := update.CallbackQuery + if query == nil { + return + } + if !g.isSenderAllowed(query.From.ID) { + g.log.Warn("dangerous callback from unauthorized sender", "user_id", query.From.ID) + g.answerDangerousCallback(ctx, b, query.ID, "You are not authorised to use this bot.", true) + return + } + + action, ok := g.consumeDangerousAction(query) + if !ok { + g.answerDangerousCallback(ctx, b, query.ID, "That action is no longer valid.", true) + return + } + + decision, _ := parseDangerousCallback(query.Data) + g.log.Info("dangerous command decision", + "command", action.command, "decision", decision, + "recipient", query.From.ID, "username", query.From.Username, + ) + + switch decision { + case "deny": + g.executeDangerousDeny(ctx, b, query, action) + case "approve": + g.executeDangerousApprove(ctx, b, query, action) + case "permanent": + g.executeDangerousPermanent(ctx, b, query, action) + default: + g.answerDangerousCallback(ctx, b, query.ID, "That action is no longer valid.", true) + } +} + +// consumeDangerousAction validates and atomically consumes the pending +// action associated with the callback query. Returns the action and true +// if valid; false if expired, wrong recipient, or already consumed. +func (g *Gateway) consumeDangerousAction(query *models.CallbackQuery) (dangerousAction, bool) { + _, token := parseDangerousCallback(query.Data) + g.dangerousMu.Lock() + action, found := g.dangerousActions[token] + if found && action.recipient == query.From.ID && action.expiresAt.After(time.Now()) { + delete(g.dangerousActions, token) + } + g.dangerousMu.Unlock() + return action, found && action.recipient == query.From.ID && action.expiresAt.After(time.Now()) +} + +func (g *Gateway) executeDangerousDeny(ctx context.Context, b *bot.Bot, query *models.CallbackQuery, action dangerousAction) { + g.answerDangerousCallback(ctx, b, query.ID, "Command denied.", false) + g.editDangerousMessage(ctx, b, query, "❌ Denied: "+action.description) +} + +func (g *Gateway) executeDangerousApprove(ctx context.Context, b *bot.Bot, query *models.CallbackQuery, action dangerousAction) { + result, err := action.onApprove(ctx) + if err != nil { + g.log.Error("dangerous command execution failed", "command", action.command, "error", err) + g.answerDangerousCallback(ctx, b, query.ID, fmt.Sprintf("Command failed: %v", err), true) + g.editDangerousMessage(ctx, b, query, fmt.Sprintf("❌ Failed: %s — %v", action.description, err)) + return + } + g.answerDangerousCallback(ctx, b, query.ID, "Approved and executed.", false) + msg := "✅ Approved: " + action.description + if result != "" { + msg += "\n\n" + result + } + g.editDangerousMessage(ctx, b, query, msg) +} + +func (g *Gateway) executeDangerousPermanent(ctx context.Context, b *bot.Bot, query *models.CallbackQuery, action dangerousAction) { + g.recordPermanentApproval(query.From.ID, action.command) + + result, err := action.onApprove(ctx) + if err != nil { + g.log.Error("dangerous command execution failed (permanent approval)", "command", action.command, "error", err) + g.answerDangerousCallback(ctx, b, query.ID, fmt.Sprintf("Command failed: %v", err), true) + g.editDangerousMessage(ctx, b, query, fmt.Sprintf("❌ Failed: %s — %v", action.description, err)) + return + } + g.answerDangerousCallback(ctx, b, query.ID, "Permanently approved and executed (valid 24h).", false) + msg := "✅ Approved (permanent, 24h): " + action.description + if result != "" { + msg += "\n\n" + result + } + g.editDangerousMessage(ctx, b, query, msg) +} + +func (g *Gateway) recordPermanentApproval(recipient int64, command string) { + scope := permanentApproval{ + CommandPattern: command, + Recipient: recipient, + GrantedAt: time.Now(), + ExpiresAt: time.Now().Add(24 * time.Hour), + Scope: fmt.Sprintf("Permanent approval for %q by user %d, expires in 24h", command, recipient), + } + g.dangerousMu.Lock() + g.permanentApprovals = append(g.permanentApprovals, scope) + now := time.Now() + kept := g.permanentApprovals[:0] + for _, pa := range g.permanentApprovals { + if pa.ExpiresAt.After(now) { + kept = append(kept, pa) + } + } + g.permanentApprovals = kept + g.dangerousMu.Unlock() + + g.log.Info("dangerous command permanently approved", "scope", scope.Scope) +} + +// hasPermanentApproval checks whether recipient has a current permanent +// approval covering the given command text. +func (g *Gateway) hasPermanentApproval(recipient int64, command string) bool { + g.dangerousMu.Lock() + defer g.dangerousMu.Unlock() + + now := time.Now() + kept := g.permanentApprovals[:0] + found := false + for _, pa := range g.permanentApprovals { + if !pa.ExpiresAt.After(now) { + continue + } + kept = append(kept, pa) + if pa.Recipient == recipient && strings.HasPrefix(command, pa.CommandPattern) { + found = true + } + } + g.permanentApprovals = kept + return found +} + +func (g *Gateway) editDangerousMessage(ctx context.Context, b *bot.Bot, query *models.CallbackQuery, text string) { + if query.Message.Message == nil { + return + } + message := query.Message.Message + if _, err := b.EditMessageText(ctx, &bot.EditMessageTextParams{ + ChatID: message.Chat.ID, + MessageID: message.ID, + Text: text, + }); err != nil { + g.log.Warn("edit dangerous message failed", "error", err) + } +} + +// ── /rollback handler ─────────────────────────────────────────── + +// rollbackHandler serves /rollback: show available checkpoints, or with +// a number, request approval to restore that checkpoint. +func (g *Gateway) rollbackHandler() bot.HandlerFunc { + return func(ctx context.Context, b *bot.Bot, update *models.Update) { + msg, ok := g.authorizedMessage(ctx, b, update) + if !ok { + return + } + if g.Dangerous == nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Rollback is not configured for this installation.") + return + } + + rest := strings.TrimSpace(restAfterTelegram(msg.Text, "/rollback", "")) + if rest == "" { + g.showCheckpoints(ctx, b, msg.Chat.ID, msg.MessageThreadID) + return + } + + num, err := strconv.Atoi(rest) + if err != nil || num < 1 { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Usage: /rollback <checkpoint number>") + return + } + g.requestRollbackApproval(ctx, b, msg, num) + } +} + +func (g *Gateway) showCheckpoints(ctx context.Context, b *bot.Bot, chatID int64, threadID int) { + checkpoints, err := g.Dangerous.ListCheckpoints(ctx) + if err != nil { + g.log.Error("list checkpoints failed", "error", err) + g.sendMessage(ctx, b, chatID, threadID, "Could not list checkpoints.") + return + } + if len(checkpoints) == 0 { + g.sendMessage(ctx, b, chatID, threadID, "No checkpoints available.") + return + } + var text strings.Builder + text.WriteString("Available checkpoints:\n\n") + for _, c := range checkpoints { + fmt.Fprintf(&text, "%d — %s (%s)", c.Number, c.Timestamp.Format("2006-01-02 15:04"), c.Label) + if c.Size != "" { + fmt.Fprintf(&text, " — %s", c.Size) + } + text.WriteByte('\n') + } + text.WriteString("\nUse /rollback <number> to restore a checkpoint.") + g.sendMessage(ctx, b, chatID, threadID, text.String()) +} + +func (g *Gateway) requestRollbackApproval(ctx context.Context, b *bot.Bot, msg *models.Message, num int) { + rest := fmt.Sprintf("%d", num) + if g.hasPermanentApproval(msg.From.ID, "/rollback") { + result, err := g.Dangerous.Rollback(ctx, num) + if err != nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, fmt.Sprintf("❌ Rollback failed: %v", err)) + return + } + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "✅ Rollback to checkpoint "+rest+":\n\n"+result) + return + } + + cmdText := fmt.Sprintf("/rollback %d", num) + desc := fmt.Sprintf("Rollback to checkpoint %d", num) + token := g.registerDangerousAction(cmdText, desc, msg.From.ID, func(ctx context.Context) (string, error) { + return g.Dangerous.Rollback(ctx, num) + }) + + params := &bot.SendMessageParams{ + ChatID: msg.Chat.ID, + Text: rollbackApprovalText(num), + ReplyMarkup: g.dangerousKeyboard(token), + } + if msg.MessageThreadID != 0 { + params.MessageThreadID = msg.MessageThreadID + } + if _, err := b.SendMessage(ctx, params); err != nil { + g.log.Error("send dangerous prompt (rollback) failed", "error", err) + } +} + +func rollbackApprovalText(num int) string { + return fmt.Sprintf( + "⚠️ **Dangerous command**\n\n"+ + "Command: `/rollback %d`\n"+ + "Effect: Restore the worktree filesystem to checkpoint %d.\n"+ + "This will discard any changes made after that checkpoint.\n\n"+ + "_This request expires in 10 minutes._", + num, num, + ) +} + +// ── /stop handler ────────────────────────────────────────────── + +// stopHandler serves /stop: terminate a background process after approval. +func (g *Gateway) stopHandler() bot.HandlerFunc { + return func(ctx context.Context, b *bot.Bot, update *models.Update) { + msg, ok := g.authorizedMessage(ctx, b, update) + if !ok { + return + } + if g.Dangerous == nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Process control is not configured for this installation.") + return + } + + rest := restAfterTelegram(msg.Text, "/stop", "") + rest = strings.TrimSpace(rest) + + if rest == "" { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + "Usage: /stop <process-name>\n\nTerminate a running background process. "+ + "This requires approval because it may discard in-progress work.") + return + } + + // Check permanent approval. + if g.hasPermanentApproval(msg.From.ID, "/stop") { + if err := g.Dangerous.StopProcess(ctx, rest); err != nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, fmt.Sprintf("❌ Stop failed: %v", err)) + return + } + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "✅ Process stopped: "+rest) + return + } + + cmdText := fmt.Sprintf("/stop %s", rest) + desc := fmt.Sprintf("Stop process %q", rest) + token := g.registerDangerousAction(cmdText, desc, msg.From.ID, func(ctx context.Context) (string, error) { + if err := g.Dangerous.StopProcess(ctx, rest); err != nil { + return "", err + } + return "", nil + }) + + params := &bot.SendMessageParams{ + ChatID: msg.Chat.ID, + Text: fmt.Sprintf( + "⚠️ **Dangerous command**\n\n"+ + "Command: `/stop %s`\n"+ + "Effect: Terminate the running background process %q.\n"+ + "This will discard any in-progress work on that process.\n\n"+ + "_This request expires in 10 minutes._", + rest, rest, + ), + ReplyMarkup: g.dangerousKeyboard(token), + } + if msg.MessageThreadID != 0 { + params.MessageThreadID = msg.MessageThreadID + } + if _, err := b.SendMessage(ctx, params); err != nil { + g.log.Error("send dangerous prompt (stop) failed", "error", err) + } + } +} + +// ── helpers ──────────────────────────────────────────────────── + +// restAfterTelegram strips a slash-command token from a Telegram message +// text, including an optional @bot suffix. +func restAfterTelegram(text, cmd, gatewayName string) string { + s := text + if gatewayName != "" { + s = strings.TrimPrefix(s, cmd+"@"+gatewayName) + } + s = strings.TrimPrefix(s, cmd) + return s +} + +func makeDangerousToken() string { + bytes := make([]byte, 16) + if _, err := rand.Read(bytes); err != nil { + panic("crypto/rand: " + err.Error()) + } + return hex.EncodeToString(bytes) +} + +// parseDangerousCallback splits a dangerous-command callback data into +// decision ("approve", "permanent", "deny") and token. +func parseDangerousCallback(data string) (decision, token string) { + data = strings.TrimPrefix(data, dangerousCmdPrefix) + decision, token, _ = strings.Cut(data, ":") + if decision != "approve" && decision != "permanent" && decision != "deny" { + return "", "" + } + return decision, token +} + +// ── /approve and /deny handlers ───────────────────────────────── + +// approveHandler serves /approve: list any pending dangerous commands, +// or approve a specific one by token. When a pending command exists, the +// user interacts via inline buttons rather than typing /approve directly; +// this handler is for the edge case where a user types /approve without +// a pending command context. +func (g *Gateway) approveHandler() bot.HandlerFunc { + return func(ctx context.Context, b *bot.Bot, update *models.Update) { + msg, ok := g.authorizedMessage(ctx, b, update) + if !ok { + return + } + if g.Dangerous == nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + "Dangerous-command approval is not configured.\n\n"+ + "Use /rollback or /stop to trigger approval inline.") + return + } + + g.dangerousMu.Lock() + now := time.Now() + var pending []dangerousAction + for key, action := range g.dangerousActions { + if !action.expiresAt.After(now) { + delete(g.dangerousActions, key) + continue + } + if action.recipient == msg.From.ID { + pending = append(pending, action) + } + } + g.dangerousMu.Unlock() + + if len(pending) == 0 { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + "No pending commands to approve.\n\n"+ + "Use /rollback or /stop to trigger a dangerous command approval inline.") + return + } + + var text strings.Builder + text.WriteString("Pending dangerous commands:\n\n") + for i, action := range pending { + fmt.Fprintf(&text, "%d. %s", i+1, action.description) + remaining := time.Until(action.expiresAt).Truncate(time.Second) + fmt.Fprintf(&text, " (expires in %s)", remaining) + text.WriteByte('\n') + } + text.WriteString("\nUse the inline buttons on each pending command to approve or deny.") + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, text.String()) + } +} + +// denyHandler serves /deny: the counterpart to /approve for rejecting +// pending dangerous commands. Like /approve, the primary interaction is +// through inline buttons on each pending command. +func (g *Gateway) denyHandler() bot.HandlerFunc { + return g.approveHandler() // Same behaviour: show pending commands. +} diff --git a/internal/channels/telegram/dangerous_test.go b/internal/channels/telegram/dangerous_test.go new file mode 100644 index 000000000..ae26ca105 --- /dev/null +++ b/internal/channels/telegram/dangerous_test.go @@ -0,0 +1,992 @@ +package telegram + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "strings" + "sync" + "testing" + "time" + + "github.com/go-telegram/bot/models" +) + +// ── DangerousCommandAuthority stub ───────────────────────────── + +type dangerousStub struct { + mu sync.Mutex + stopCalls []string + rollbackCalls []int + checkpoints []CheckpointInfo + stopErr error + rollbackErr error + rollbackResult string + checkpointsErr error +} + +func (s *dangerousStub) StopProcess(_ context.Context, spec string) error { + s.mu.Lock() + defer s.mu.Unlock() + s.stopCalls = append(s.stopCalls, spec) + return s.stopErr +} + +func (s *dangerousStub) Rollback(_ context.Context, num int) (string, error) { + s.mu.Lock() + defer s.mu.Unlock() + s.rollbackCalls = append(s.rollbackCalls, num) + if s.rollbackErr != nil { + return "", s.rollbackErr + } + return s.rollbackResult, nil +} + +func (s *dangerousStub) ListCheckpoints(_ context.Context) ([]CheckpointInfo, error) { + if s.checkpointsErr != nil { + return nil, s.checkpointsErr + } + return s.checkpoints, nil +} + +// messageText returns the text content from a Telegram request, +// checking both regular text messages and rich messages. +func messageText(requests []telegramRequest, index int) string { + if index >= len(requests) { + return "" + } + req := requests[index] + if text := req.form["text"]; text != "" { + return text + } + return req.form["rich_message"] +} + +// ── Tests ────────────────────────────────────────────────────── + +func TestRollbackListsCheckpoints(t *testing.T) { + const allowedUserID = int64(42) + now := time.Date(2026, 1, 15, 10, 30, 0, 0, time.UTC) + stub := &dangerousStub{ + checkpoints: []CheckpointInfo{ + {Number: 3, Timestamp: now, Label: "After gate fix", Size: "12 MB"}, + {Number: 2, Timestamp: now.Add(-1 * time.Hour), Label: "Baseline", Size: "10 MB"}, + {Number: 1, Timestamp: now.Add(-2 * time.Hour), Label: "Initial checkout", Size: "8 MB"}, + }, + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback", + }, + }) + + if len(*requests) == 0 { + t.Fatal("rollback list sent no response") + } + text := messageText(*requests, 0) + for _, want := range []string{"Available checkpoints", "3 — 2026-01-15 10:30", "12 MB", "After gate fix"} { + if !strings.Contains(text, want) { + t.Errorf("checkpoint list missing %q: %s", want, text) + } + } +} + +func TestRollbackEmptyCheckpoints(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} // no checkpoints + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "No checkpoints") { + t.Errorf("expected 'No checkpoints' message, got: %s", text) + } +} + +func TestRollbackCheckpointError(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{checkpointsErr: fmt.Errorf("storage offline")} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "Could not list") { + t.Errorf("expected error message, got: %s", text) + } +} + +func TestRollbackWithNumberRequiresApproval(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{ + rollbackResult: "Restored to checkpoint 2: 15 files changed, 3 removed.", + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 2", + }, + }) + + if len(*requests) == 0 { + t.Fatal("rollback approval prompt sent no response") + } + text := (*requests)[0].form["text"] + if !strings.Contains(text, "Dangerous command") { + t.Errorf("expected dangerous command prompt, got: %s", text) + } + if !strings.Contains(text, "/rollback 2") { + t.Errorf("expected command text in prompt, got: %s", text) + } + if !strings.Contains(text, "expires in 10 minutes") { + t.Errorf("expected expiry notice, got: %s", text) + } + + // Verify inline keyboard has three buttons. + var markup models.InlineKeyboardMarkup + if err := json.Unmarshal([]byte((*requests)[0].form["reply_markup"]), &markup); err != nil { + t.Fatalf("decode reply markup: %v", err) + } + if len(markup.InlineKeyboard) != 3 { + t.Fatalf("keyboard rows = %d, want 3 (Approve/Approve Permanently/Deny)", len(markup.InlineKeyboard)) + } + + buttons := []string{ + markup.InlineKeyboard[0][0].Text, + markup.InlineKeyboard[1][0].Text, + markup.InlineKeyboard[2][0].Text, + } + if buttons[0] != "Approve this time" || buttons[1] != "Approve Permanently" || buttons[2] != "Deny" { + t.Errorf("button labels = %v, want [Approve this time, Approve Permanently, Deny]", buttons) + } + + // Verify callback data prefix. + if !strings.HasPrefix(markup.InlineKeyboard[0][0].CallbackData, dangerousCmdPrefix+"approve:") { + t.Errorf("approve callback = %q, want prefix %s", markup.InlineKeyboard[0][0].CallbackData, dangerousCmdPrefix+"approve:") + } + if !strings.HasPrefix(markup.InlineKeyboard[1][0].CallbackData, dangerousCmdPrefix+"permanent:") { + t.Errorf("permanent callback = %q", markup.InlineKeyboard[1][0].CallbackData) + } + if !strings.HasPrefix(markup.InlineKeyboard[2][0].CallbackData, dangerousCmdPrefix+"deny:") { + t.Errorf("deny callback = %q", markup.InlineKeyboard[2][0].CallbackData) + } + + // Verify no rollback was executed yet (still pending approval). + if len(stub.rollbackCalls) != 0 { + t.Errorf("rollback was executed before approval: %v", stub.rollbackCalls) + } +} + +func TestRollbackApprovalExecutes(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{ + rollbackResult: "Restored to checkpoint 2: 15 files changed.", + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + // Step 1: Trigger the approval prompt. + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 2", + }, + }) + + // Extract the approve callback token. + var markup models.InlineKeyboardMarkup + if err := json.Unmarshal([]byte((*requests)[0].form["reply_markup"]), &markup); err != nil { + t.Fatalf("decode markup: %v", err) + } + approveCallback := markup.InlineKeyboard[0][0].CallbackData + + *requests = nil + + // Step 2: Send the approval callback. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: approveCallback, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + // Verify rollback was executed. + if len(stub.rollbackCalls) != 1 || stub.rollbackCalls[0] != 2 { + t.Errorf("rollbackCalls = %v, want [2]", stub.rollbackCalls) + } + + // Verify acknowledgement and edit. + var answered, edited bool + for _, req := range *requests { + if req.method == "answerCallbackQuery" { + answered = true + if !strings.Contains(req.form["text"], "Approved") { + t.Errorf("acknowledgement = %q", req.form["text"]) + } + } + if req.method == "editMessageText" { + edited = true + if !strings.Contains(req.form["text"], "Restored to checkpoint 2") { + t.Errorf("edit text = %q", req.form["text"]) + } + } + } + if !answered || !edited { + t.Fatalf("answered=%t edited=%t, requests: %#v", answered, edited, *requests) + } +} + +func TestRollbackWithBadNumber(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback abc", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "Usage: /rollback") { + t.Errorf("expected usage message, got: %s", text) + } + if len(stub.rollbackCalls) != 0 { + t.Error("rollback was called with bad argument") + } +} + +func TestStopRequiresApproval(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.stopHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/stop npm-dev-server", + }, + }) + + text := (*requests)[0].form["text"] + if !strings.Contains(text, "Dangerous command") { + t.Errorf("expected dangerous command prompt, got: %s", text) + } + if !strings.Contains(text, "/stop npm-dev-server") { + t.Errorf("expected command text in prompt, got: %s", text) + } + + // Verify no process was stopped yet. + if len(stub.stopCalls) != 0 { + t.Errorf("stop was executed before approval: %v", stub.stopCalls) + } +} + +func TestStopApprovalExecutes(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + // Step 1: Trigger the approval prompt. + g.stopHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/stop my-process", + }, + }) + + var markup models.InlineKeyboardMarkup + if err := json.Unmarshal([]byte((*requests)[0].form["reply_markup"]), &markup); err != nil { + t.Fatalf("decode markup: %v", err) + } + approveCallback := markup.InlineKeyboard[0][0].CallbackData + + *requests = nil + + // Step 2: Approve. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: approveCallback, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + if len(stub.stopCalls) != 1 || stub.stopCalls[0] != "my-process" { + t.Errorf("stopCalls = %v, want [my-process]", stub.stopCalls) + } +} + +func TestStopNoArgument(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.stopHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/stop", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "Usage: /stop") { + t.Errorf("expected usage message, got: %s", text) + } +} + +func TestDangerousCallbackRejectsUnauthorizedSender(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{ + rollbackResult: "ok", + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + // Register a fake action for user 42. + _ = g.registerDangerousAction("/rollback 1", "rollback test", 42, func(ctx context.Context) (string, error) { + return "ok", nil + }) + // Find the token. + g.dangerousMu.Lock() + var token string + for t := range g.dangerousActions { + token = t + } + g.dangerousMu.Unlock() + + // Attempt approval from user 99 (not allowed). + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: 99}, + Data: dangerousCmdPrefix + "approve:" + token, + }, + }) + + var answer *telegramRequest + for i := range *requests { + if (*requests)[i].method == "answerCallbackQuery" { + answer = &(*requests)[i] + } + } + if answer == nil || answer.form["show_alert"] != "true" { + t.Fatalf("unauthorized rejection did not alert; requests: %#v", *requests) + } + if len(stub.rollbackCalls) != 0 { + t.Error("unauthorized sender executed rollback") + } +} + +func TestDangerousCallbackExpiredToken(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + // Register and immediately expire. + token := g.registerDangerousAction("/rollback 1", "expired", allowedUserID, func(ctx context.Context) (string, error) { + return "ok", nil + }) + + g.dangerousMu.Lock() + action := g.dangerousActions[token] + action.expiresAt = time.Now().Add(-1 * time.Minute) // force expiry + g.dangerousActions[token] = action + g.dangerousMu.Unlock() + + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "approve:" + token, + }, + }) + + if len(stub.rollbackCalls) != 0 { + t.Error("expired token executed rollback") + } + // Find the rejection answer. + for _, req := range *requests { + if req.method == "answerCallbackQuery" && req.form["text"] == "That action is no longer valid." { + return // pass + } + } + t.Errorf("no 'no longer valid' answer; requests: %#v", *requests) +} + +func TestDangerousCallbackSingleUse(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + token := g.registerDangerousAction("/rollback 1", "single-use test", allowedUserID, func(ctx context.Context) (string, error) { + return g.Dangerous.Rollback(ctx, 1) + }) + + // First approval should work. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-1", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "approve:" + token, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + if len(stub.rollbackCalls) != 1 { + t.Fatalf("first approval did not execute: calls=%d", len(stub.rollbackCalls)) + } + + *requests = nil + + // Second approval (replay) should be rejected. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-2", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "approve:" + token, + }, + }) + + if len(stub.rollbackCalls) != 1 { + t.Errorf("replay executed rollback again: calls=%d", len(stub.rollbackCalls)) + } + + for _, req := range *requests { + if req.method == "answerCallbackQuery" && req.form["text"] == "That action is no longer valid." { + return + } + } + t.Errorf("replay was not rejected; requests: %#v", *requests) +} + +func TestDangerousCallbackDeny(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + token := g.registerDangerousAction("/rollback 1", "deny test", allowedUserID, func(ctx context.Context) (string, error) { + return "ok", nil + }) + + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "deny:" + token, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + if len(stub.rollbackCalls) != 0 { + t.Error("deny executed rollback") + } + + var foundDeny bool + for _, req := range *requests { + if req.method == "answerCallbackQuery" && strings.Contains(req.form["text"], "denied") { + foundDeny = true + } + } + if !foundDeny { + t.Errorf("deny was not acknowledged; requests: %#v", *requests) + } +} + +func TestDangerousCallbackExecutionFailure(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{rollbackErr: fmt.Errorf("checkpoint corrupted")} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + token := g.registerDangerousAction("/rollback 1", "failure test", allowedUserID, func(ctx context.Context) (string, error) { + return g.Dangerous.Rollback(ctx, 1) + }) + + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "approve:" + token, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + var foundFail bool + for _, req := range *requests { + if req.method == "answerCallbackQuery" && strings.Contains(req.form["text"], "Command failed") { + foundFail = true + } + if req.method == "editMessageText" && strings.Contains(req.form["text"], "Failed") { + foundFail = true + } + } + if !foundFail { + t.Errorf("execution failure was not reported; requests: %#v", *requests) + } +} + +func TestPermanentApprovalSkipsInlineKeyboard(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{ + rollbackResult: "Restored (permanent approval).", + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + + // Grant permanent approval for rollback. + g.dangerousMu.Lock() + g.permanentApprovals = append(g.permanentApprovals, permanentApproval{ + CommandPattern: "/rollback", + Recipient: allowedUserID, + GrantedAt: time.Now(), + ExpiresAt: time.Now().Add(24 * time.Hour), + Scope: "test permanent approval", + }) + g.dangerousMu.Unlock() + + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 3", + }, + }) + + // Should execute immediately without inline keyboard. + if len(stub.rollbackCalls) != 1 || stub.rollbackCalls[0] != 3 { + t.Errorf("rollbackCalls = %v, want [3]", stub.rollbackCalls) + } + + text := messageText(*requests, 0) + if !strings.Contains(text, "Restored (permanent approval)") { + t.Errorf("expected immediate execution result, got: %s", text) + } + if _, ok := (*requests)[0].form["reply_markup"]; ok { + t.Error("permanent approval path rendered inline keyboard (should not)") + } +} + +func TestPermanentApprovalExpired(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + + // Grant expired permanent approval. + g.dangerousMu.Lock() + g.permanentApprovals = append(g.permanentApprovals, permanentApproval{ + CommandPattern: "/rollback", + Recipient: allowedUserID, + GrantedAt: time.Now().Add(-48 * time.Hour), + ExpiresAt: time.Now().Add(-1 * time.Minute), // expired + Scope: "expired test", + }) + g.dangerousMu.Unlock() + + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 2", + }, + }) + + // Should show inline keyboard (approval required). + text := (*requests)[0].form["text"] + if !strings.Contains(text, "Dangerous command") { + t.Errorf("expected dangerous command prompt for expired permanent approval, got: %s", text) + } + if _, ok := (*requests)[0].form["reply_markup"]; !ok { + t.Error("expired permanent approval should still require inline keyboard") + } +} + +func TestPermanentApprovalButtonGrantsApproval(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{ + rollbackResult: "Restored after permanent approval grant.", + } + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + // Step 1: Trigger approval prompt. + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 1", + }, + }) + + // Extract permanent approval callback. + var markup models.InlineKeyboardMarkup + if err := json.Unmarshal([]byte((*requests)[0].form["reply_markup"]), &markup); err != nil { + t.Fatalf("decode markup: %v", err) + } + permanentCallback := markup.InlineKeyboard[1][0].CallbackData + + *requests = nil + + // Step 2: Click Approve Permanently. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: permanentCallback, + Message: models.MaybeInaccessibleMessage{ + Type: models.MaybeInaccessibleMessageTypeMessage, + Message: &models.Message{ID: 9, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}}, + }, + }, + }) + + // Should execute and record permanent approval. + if len(stub.rollbackCalls) != 1 || stub.rollbackCalls[0] != 1 { + t.Errorf("rollbackCalls = %v, want [1]", stub.rollbackCalls) + } + + // Verify permanent approval was recorded. + g.dangerousMu.Lock() + hasPerm := false + for _, pa := range g.permanentApprovals { + if pa.CommandPattern == "/rollback 1" && pa.Recipient == allowedUserID { + hasPerm = true + if pa.ExpiresAt.Before(time.Now().Add(23 * time.Hour)) { + t.Error("permanent approval expiry too short") + } + } + } + g.dangerousMu.Unlock() + if !hasPerm { + t.Error("permanent approval was not recorded") + } +} + +func TestPermanentApprovalScopedToRecipient(t *testing.T) { + const allowedUserID = int64(42) + const otherUserID = int64(99) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID, otherUserID}, slog.Default()) + g.Dangerous = stub + + // Grant permanent approval for user 42. + g.dangerousMu.Lock() + g.permanentApprovals = append(g.permanentApprovals, permanentApproval{ + CommandPattern: "/rollback", + Recipient: 42, + GrantedAt: time.Now(), + ExpiresAt: time.Now().Add(24 * time.Hour), + Scope: "recipient scoping test", + }) + g.dangerousMu.Unlock() + + b, requests := newTelegramTestBot(t) + + // User 99 tries /rollback — should require approval. + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: otherUserID}, + Chat: models.Chat{ID: 8, Type: models.ChatTypePrivate}, + Text: "/rollback 2", + }, + }) + + text := (*requests)[0].form["text"] + if !strings.Contains(text, "Dangerous command") { + t.Errorf("user 99 should require approval; got: %s", text) + } +} + +func TestApproveHandlerShowsPendingCommands(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + + // Register a pending command. + g.registerDangerousAction("/rollback 2", "Rollback to checkpoint 2", allowedUserID, func(ctx context.Context) (string, error) { + return "", nil + }) + + b, requests := newTelegramTestBot(t) + + g.approveHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/approve", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "Pending dangerous commands") { + t.Errorf("expected pending list, got: %s", text) + } + if !strings.Contains(text, "Rollback to checkpoint 2") { + t.Errorf("expected pending command description, got: %s", text) + } +} + +func TestApproveHandlerNoPendingCommands(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + + b, requests := newTelegramTestBot(t) + + g.approveHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/approve", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "No pending commands") { + t.Errorf("expected no pending message, got: %s", text) + } +} + +func TestRollbackNotConfigured(t *testing.T) { + const allowedUserID = int64(42) + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + // Dangerous is nil. + b, requests := newTelegramTestBot(t) + + g.rollbackHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/rollback 1", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "not configured") { + t.Errorf("expected not configured message, got: %s", text) + } +} + +func TestStopNotConfigured(t *testing.T) { + const allowedUserID = int64(42) + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + // Dangerous is nil. + b, requests := newTelegramTestBot(t) + + g.stopHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + Text: "/stop process", + }, + }) + + text := messageText(*requests, 0) + if !strings.Contains(text, "not configured") { + t.Errorf("expected not configured message, got: %s", text) + } +} + +func TestDangerousCommandHelpContainsNewCommands(t *testing.T) { + const allowedUserID = int64(42) + + var sentText string + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + b, requests := newTelegramTestBot(t) + + g.helpHandler()(context.Background(), b, &models.Update{ + Message: &models.Message{ + From: &models.User{ID: allowedUserID}, + Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, + }, + }) + + for _, req := range *requests { + if req.method == "sendRichMessage" { + sentText = req.form["rich_message"] + } + } + if sentText == "" { + t.Fatal("help sent no rich message") + } + for _, want := range []string{"/rollback", "/stop"} { + if !strings.Contains(sentText, want) { + t.Errorf("help text missing %q", want) + } + } + // /approve and /deny should NOT appear in help (they are hidden). + for _, hidden := range []string{"/approve\n", "/deny\n"} { + if strings.Contains(sentText, hidden) { + t.Errorf("help text contains hidden command %q", hidden) + } + } +} + +func TestParseDangerousCallback(t *testing.T) { + tests := []struct { + name string + data string + decision string + token string + }{ + {name: "approve", data: dangerousCmdPrefix + "approve:abc123", decision: "approve", token: "abc123"}, + {name: "permanent", data: dangerousCmdPrefix + "permanent:def456", decision: "permanent", token: "def456"}, + {name: "deny", data: dangerousCmdPrefix + "deny:ghi789", decision: "deny", token: "ghi789"}, + {name: "wrong prefix", data: "other:approve:abc", decision: "", token: ""}, + {name: "unknown decision", data: dangerousCmdPrefix + "unknown:abc", decision: "", token: ""}, + {name: "empty", data: "", decision: "", token: ""}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + decision, token := parseDangerousCallback(tt.data) + if decision != tt.decision || token != tt.token { + t.Errorf("parseDangerousCallback(%q) = (%q, %q), want (%q, %q)", + tt.data, decision, token, tt.decision, tt.token) + } + }) + } +} + +func TestDangerousCommandSpecDescriptions(t *testing.T) { + found := make(map[string]bool) + for _, spec := range gatewayCommandSpecs { + found[spec.Command] = true + } + for _, cmd := range []string{"rollback", "stop"} { + if !found[cmd] { + t.Errorf("/%s is missing from gatewayCommandSpecs", cmd) + } + } + for _, cmd := range []string{"approve", "deny"} { + if found[cmd] { + t.Errorf("/%s should NOT be in gatewayCommandSpecs (hidden command)", cmd) + } + } +} + +func TestDangerousCallbackRejectsWrongRecipient(t *testing.T) { + const allowedUserID = int64(42) + const otherUserID = int64(43) + stub := &dangerousStub{rollbackResult: "ok"} + g := New("1:test", "", "", []int64{allowedUserID, otherUserID}, slog.Default()) + g.Dangerous = stub + b, _ := newTelegramTestBot(t) + + token := g.registerDangerousAction("/rollback 1", "recipient test", allowedUserID, func(ctx context.Context) (string, error) { + return "ok", nil + }) + + // User 43 tries to approve user 42's command. + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: otherUserID}, + Data: dangerousCmdPrefix + "approve:" + token, + }, + }) + + if len(stub.rollbackCalls) != 0 { + t.Error("wrong recipient executed rollback") + } +} + +func TestMalformedDangerousCallback(t *testing.T) { + const allowedUserID = int64(42) + stub := &dangerousStub{} + g := New("1:test", "", "", []int64{allowedUserID}, slog.Default()) + g.Dangerous = stub + b, requests := newTelegramTestBot(t) + + g.handleDangerousCallback(context.Background(), b, &models.Update{ + CallbackQuery: &models.CallbackQuery{ + ID: "callback-id", + From: models.User{ID: allowedUserID}, + Data: dangerousCmdPrefix + "bad-format", + }, + }) + + for _, req := range *requests { + if req.method == "answerCallbackQuery" && req.form["text"] == "That action is no longer valid." { + return + } + } + t.Errorf("malformed callback not rejected; requests: %#v", *requests) +} diff --git a/internal/channels/telegram/telegram.go b/internal/channels/telegram/telegram.go index aa738f0af..5611c8287 100644 --- a/internal/channels/telegram/telegram.go +++ b/internal/channels/telegram/telegram.go @@ -49,6 +49,11 @@ type Gateway struct { // deferral persistence, and installation; Telegram only presents it. Updates UpdateService + // Dangerous is the sandbox/process authority for /rollback and /stop. + // When nil, those commands return "not configured". The composition + // root supplies this; Telegram only renders approval UX. + Dangerous DangerousCommandAuthority + // restartCh carries /restart requests from a bot handler to the // supervisor loop in Start. Buffered so a handler never blocks. restartCh chan restartRequest @@ -61,6 +66,11 @@ type Gateway struct { updateInProgress bool updateActions map[string]updateAction + // dangerous command approval state + dangerousMu sync.Mutex + dangerousActions map[string]dangerousAction + permanentApprovals []permanentApproval + log *slog.Logger bot *bot.Bot webhookCancel context.CancelFunc @@ -86,15 +96,17 @@ type ReleaseAnnouncer interface { // processing. func New(token, webhookURL, webhookSecret string, allowedUserIDs []int64, log *slog.Logger) *Gateway { return &Gateway{ - Token: token, - WebhookURL: webhookURL, - WebhookSecret: webhookSecret, - AllowedUserIDs: allowedUserIDs, - restartCh: make(chan restartRequest, 1), - modelCallbacks: make(map[string]string), - providerCallbacks: make(map[string]string), - updateActions: make(map[string]updateAction), - log: log.With("component", "gateway-telegram"), + Token: token, + WebhookURL: webhookURL, + WebhookSecret: webhookSecret, + AllowedUserIDs: allowedUserIDs, + restartCh: make(chan restartRequest, 1), + modelCallbacks: make(map[string]string), + providerCallbacks: make(map[string]string), + updateActions: make(map[string]updateAction), + dangerousActions: make(map[string]dangerousAction), + permanentApprovals: nil, + log: log.With("component", "gateway-telegram"), } } @@ -177,6 +189,10 @@ func (g *Gateway) launch(ctx context.Context, router *gateway.Router) (*bot.Bot, b.RegisterHandler(bot.HandlerTypeMessageText, "/start", bot.MatchTypeExact, g.startHandler()) b.RegisterHandler(bot.HandlerTypeMessageText, "/help", bot.MatchTypeExact, g.helpHandler()) b.RegisterHandler(bot.HandlerTypeMessageText, "/restart", bot.MatchTypeExact, g.restartHandler()) + b.RegisterHandler(bot.HandlerTypeMessageText, "/rollback", bot.MatchTypePrefix, g.rollbackHandler()) + b.RegisterHandler(bot.HandlerTypeMessageText, "/stop", bot.MatchTypePrefix, g.stopHandler()) + b.RegisterHandler(bot.HandlerTypeMessageText, "/approve", bot.MatchTypeExact, g.approveHandler()) + b.RegisterHandler(bot.HandlerTypeMessageText, "/deny", bot.MatchTypeExact, g.denyHandler()) // Publish the command list so Telegram renders a menu. Without this // the commands are undiscoverable and the LLM, having no idea they @@ -330,6 +346,8 @@ func (g *Gateway) defaultHandler(router *gateway.Router) bot.HandlerFunc { return func(ctx context.Context, b *bot.Bot, update *models.Update) { if update.CallbackQuery != nil { switch { + case strings.HasPrefix(update.CallbackQuery.Data, dangerousCmdPrefix): + g.handleDangerousCallback(ctx, b, update) case strings.HasPrefix(update.CallbackQuery.Data, providerCallbackPrefix): g.handleProviderCallback(ctx, b, update, router) case strings.HasPrefix(update.CallbackQuery.Data, modelCallbackPrefix): diff --git a/internal/channels/telegram/telegram_test.go b/internal/channels/telegram/telegram_test.go index f9630f7cd..808e410c9 100644 --- a/internal/channels/telegram/telegram_test.go +++ b/internal/channels/telegram/telegram_test.go @@ -161,7 +161,7 @@ func TestVersionReportsBothComponents(t *testing.T) { // dangerous and should not be discoverable by casual chat users. Commands in // this set may still be executable if typed explicitly — they just shouldn't // appear on Telegram's discoverability surfaces. -var telegramHiddenCommands = map[string]bool{"approve": true} +var telegramHiddenCommands = map[string]bool{"approve": true, "deny": true} func TestPublishedCommandsMatchExecutableCommandSurface(t *testing.T) { executable := make(map[string]bool)