3056a540bf
Add tools.cron.command_allowed_remotes so remote channels can be explicitly allowlisted for command-executing cron jobs. Entries support channel names, channel:chat_id pairs, and a literal * to allow every non-empty channel while preserving the default deny posture. The existing allow_command and command_confirm checks still apply after the channel gate. Update tests, config examples, and cron documentation for the new option.
971 lines
29 KiB
Go
971 lines
29 KiB
Go
package tools
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/sipeed/picoclaw/pkg/bus"
|
|
"github.com/sipeed/picoclaw/pkg/config"
|
|
"github.com/sipeed/picoclaw/pkg/cron"
|
|
)
|
|
|
|
type stubJobExecutor struct {
|
|
response string
|
|
err error
|
|
alreadySent bool // simulate message tool having already sent in this round
|
|
lastPrompt string
|
|
lastKey string
|
|
lastChan string
|
|
lastChatID string
|
|
publishedResp string
|
|
publishedChan string
|
|
publishedChatID string
|
|
publishedKey string
|
|
}
|
|
|
|
func (s *stubJobExecutor) ProcessDirectWithChannel(
|
|
_ context.Context,
|
|
content, sessionKey, channel, chatID string,
|
|
) (string, error) {
|
|
s.lastPrompt = content
|
|
s.lastKey = sessionKey
|
|
s.lastChan = channel
|
|
s.lastChatID = chatID
|
|
return s.response, s.err
|
|
}
|
|
|
|
func (s *stubJobExecutor) PublishResponseIfNeeded(
|
|
_ context.Context,
|
|
channel, chatID, sessionKey, response string,
|
|
) {
|
|
if s.alreadySent {
|
|
return
|
|
}
|
|
s.publishedResp = response
|
|
s.publishedChan = channel
|
|
s.publishedChatID = chatID
|
|
s.publishedKey = sessionKey
|
|
}
|
|
|
|
func newTestCronToolWithExecutorAndConfig(t *testing.T, executor JobExecutor, cfg *config.Config) *CronTool {
|
|
t.Helper()
|
|
storePath := filepath.Join(t.TempDir(), "cron.json")
|
|
cronService := cron.NewCronService(storePath, nil)
|
|
msgBus := bus.NewMessageBus()
|
|
tool, err := NewCronTool(cronService, executor, msgBus, t.TempDir(), true, 0, cfg)
|
|
if err != nil {
|
|
t.Fatalf("NewCronTool() error: %v", err)
|
|
}
|
|
return tool
|
|
}
|
|
|
|
func newTestCronToolWithConfig(t *testing.T, cfg *config.Config) *CronTool {
|
|
t.Helper()
|
|
return newTestCronToolWithExecutorAndConfig(t, nil, cfg)
|
|
}
|
|
|
|
func newTestCronTool(t *testing.T) *CronTool {
|
|
t.Helper()
|
|
return newTestCronToolWithConfig(t, config.DefaultConfig())
|
|
}
|
|
|
|
func parseCronJobResult(t *testing.T, result *ToolResult) cron.CronJob {
|
|
t.Helper()
|
|
text := result.ForLLM
|
|
if idx := strings.Index(text, "{"); idx >= 0 {
|
|
text = text[idx:]
|
|
}
|
|
var job cron.CronJob
|
|
if err := json.Unmarshal([]byte(text), &job); err != nil {
|
|
t.Fatalf("failed to parse cron job JSON %q: %v", result.ForLLM, err)
|
|
}
|
|
return job
|
|
}
|
|
|
|
// TestCronTool_CommandBlockedFromRemoteChannel verifies command scheduling is restricted by default.
|
|
func TestCronTool_CommandBlockedFromRemoteChannel(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected command scheduling to be blocked from remote channel")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "restricted to internal channels or configured remote channels") {
|
|
t.Errorf("expected remote restriction message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedFromRemoteChannelAllowlist(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{"telegram"}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected command scheduling from allowed remote channel to succeed, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedFromRemoteChatIDAllowlist(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{" telegram:1234567890 "}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "1234567890")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected command scheduling from allowed remote chat to succeed, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedFromRemoteWildcardAllowlist(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{"*"}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected wildcard allowlist to allow remote command scheduling, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedRemoteWildcardRequiresNonEmptyChannel(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{"*"}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected missing channel to remain blocked even with wildcard allowlist")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "no session context") {
|
|
t.Errorf("expected session context error, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandBlockedFromDifferentRemoteChatID(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{"telegram:1234567890"}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "other-chat")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected command scheduling from non-allowlisted remote chat to fail")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "restricted to internal channels or configured remote channels") {
|
|
t.Errorf("expected remote restriction message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedRemoteRequiresConfirmWhenAllowCommandDisabled(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.AllowCommand = false
|
|
cfg.Tools.Cron.CommandAllowedRemotes = []string{"telegram"}
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected allowlisted remote command scheduling to require confirm when allow_command is disabled")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "command_confirm=true") {
|
|
t.Errorf("expected command_confirm requirement message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_AllowCommandDoesNotBypassRemoteAllowlist(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.AllowCommand = true
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected allow_command=true not to bypass remote allowlist")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "restricted to internal channels or configured remote channels") {
|
|
t.Errorf("expected remote restriction message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandDoesNotRequireConfirmByDefault(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected command scheduling without confirm to succeed by default, got: %s", result.ForLLM)
|
|
}
|
|
if !strings.Contains(result.ForLLM, "Cron job added") {
|
|
t.Errorf("expected 'Cron job added', got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandRequiresConfirmWhenAllowCommandDisabled(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.AllowCommand = false
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected command scheduling to require confirm when allow_command is disabled")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "command_confirm=true") {
|
|
t.Errorf("expected command_confirm requirement message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandAllowedWithConfirmWhenAllowCommandDisabled(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.AllowCommand = false
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf(
|
|
"expected command scheduling with confirm to succeed when allow_command is disabled, got: %s",
|
|
result.ForLLM,
|
|
)
|
|
}
|
|
if !strings.Contains(result.ForLLM, "Cron job added") {
|
|
t.Errorf("expected 'Cron job added', got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandBlockedWhenExecDisabled(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Exec.Enabled = false
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected command scheduling to be blocked when exec is disabled")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "command execution is disabled") {
|
|
t.Errorf("expected exec disabled message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
// TestCronTool_CommandAllowedFromInternalChannel verifies command scheduling works from internal channels
|
|
func TestCronTool_CommandAllowedFromInternalChannel(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "check disk",
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected command scheduling to succeed from internal channel, got: %s", result.ForLLM)
|
|
}
|
|
if !strings.Contains(result.ForLLM, "Cron job added") {
|
|
t.Errorf("expected 'Cron job added', got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
// TestCronTool_AddJobRequiresSessionContext verifies fail-closed when channel/chatID missing
|
|
func TestCronTool_AddJobRequiresSessionContext(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
result := tool.Execute(context.Background(), map[string]any{
|
|
"action": "add",
|
|
"message": "reminder",
|
|
"at_seconds": float64(60),
|
|
})
|
|
|
|
if !result.IsError {
|
|
t.Fatal("expected error when session context is missing")
|
|
}
|
|
if !strings.Contains(result.ForLLM, "no session context") {
|
|
t.Errorf("expected 'no session context' message, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
// TestCronTool_NonCommandJobAllowedFromRemoteChannel verifies regular reminders work from any channel
|
|
func TestCronTool_NonCommandJobAllowedFromRemoteChannel(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "add",
|
|
"message": "time to stretch",
|
|
"at_seconds": float64(600),
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected non-command reminder to succeed from remote channel, got: %s", result.ForLLM)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_GetReturnsFullJobPayload(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
everyMS := int64(60_000)
|
|
message := strings.Repeat("daily briefing details ", 8)
|
|
job, err := tool.cronService.AddJob(
|
|
"daily",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
message,
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "get",
|
|
"job_id": job.ID,
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("get failed: %s", result.ForLLM)
|
|
}
|
|
got := parseCronJobResult(t, result)
|
|
if got.ID != job.ID || got.Payload.Message != message || got.Payload.Channel != "telegram" ||
|
|
got.Payload.To != "chat-1" {
|
|
t.Fatalf("get returned wrong payload: %+v", got)
|
|
}
|
|
if got.Schedule.Kind != "every" || got.Schedule.EveryMS == nil || *got.Schedule.EveryMS != everyMS {
|
|
t.Fatalf("get returned wrong schedule: %+v", got.Schedule)
|
|
}
|
|
if got.State.NextRunAtMS == nil {
|
|
t.Fatal("get should include next run state")
|
|
}
|
|
}
|
|
|
|
func TestCronTool_UpdateSchedulePreservesPayload(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
original, err := tool.cronService.AddJob(
|
|
"AI daily",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"fetch RSS, include source links",
|
|
"weixin",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": original.ID,
|
|
"cron_expr": "30 10 * * *",
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("update failed: %s", result.ForLLM)
|
|
}
|
|
updated, ok := tool.cronService.GetJob(original.ID)
|
|
if !ok {
|
|
t.Fatal("updated job not found")
|
|
}
|
|
if updated.ID != original.ID || updated.CreatedAtMS != original.CreatedAtMS {
|
|
t.Fatalf("identity changed after update: before=%+v after=%+v", original, updated)
|
|
}
|
|
if updated.Payload.Message != original.Payload.Message || updated.Payload.Channel != original.Payload.Channel ||
|
|
updated.Payload.To != original.Payload.To {
|
|
t.Fatalf("payload was not preserved: %+v", updated.Payload)
|
|
}
|
|
if updated.Schedule.Kind != "cron" || updated.Schedule.Expr != "30 10 * * *" {
|
|
t.Fatalf("schedule not updated: %+v", updated.Schedule)
|
|
}
|
|
if updated.DeleteAfterRun {
|
|
t.Fatal("cron schedule should not delete after run")
|
|
}
|
|
}
|
|
|
|
func TestCronTool_UpdateMessagePreservesScheduleAndNextRun(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
everyMS := int64(120_000)
|
|
original, err := tool.cronService.AddJob(
|
|
"reminder",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
"old message",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
if original.State.NextRunAtMS == nil {
|
|
t.Fatal("expected original next run")
|
|
}
|
|
nextRunBefore := *original.State.NextRunAtMS
|
|
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": original.ID,
|
|
"message": "new message",
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("update failed: %s", result.ForLLM)
|
|
}
|
|
updated, _ := tool.cronService.GetJob(original.ID)
|
|
if updated.Payload.Message != "new message" {
|
|
t.Fatalf("message not updated: %+v", updated.Payload)
|
|
}
|
|
if updated.Name != "reminder" {
|
|
t.Fatalf("name should be preserved, got %q", updated.Name)
|
|
}
|
|
if updated.Schedule.Kind != "every" || updated.Schedule.EveryMS == nil || *updated.Schedule.EveryMS != everyMS {
|
|
t.Fatalf("schedule should be preserved: %+v", updated.Schedule)
|
|
}
|
|
if updated.State.NextRunAtMS == nil || *updated.State.NextRunAtMS != nextRunBefore {
|
|
t.Fatalf("next run should be preserved: before=%d after=%v", nextRunBefore, updated.State.NextRunAtMS)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_UpdateValidationErrors(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
job, err := tool.cronService.AddJob(
|
|
"job",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"message",
|
|
"cli",
|
|
"direct",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args map[string]any
|
|
want string
|
|
}{
|
|
{
|
|
name: "invalid job id",
|
|
args: map[string]any{"action": "update", "job_id": "missing", "message": "new"},
|
|
want: "not found",
|
|
},
|
|
{
|
|
name: "missing patch",
|
|
args: map[string]any{"action": "update", "job_id": job.ID},
|
|
want: "at least one update field",
|
|
},
|
|
{
|
|
name: "multiple schedule fields",
|
|
args: map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"every_seconds": float64(60),
|
|
"cron_expr": "0 9 * * *",
|
|
},
|
|
want: "only one of",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tool.Execute(ctx, tt.args)
|
|
if !result.IsError {
|
|
t.Fatalf("expected error, got: %s", result.ForLLM)
|
|
}
|
|
if !strings.Contains(result.ForLLM, tt.want) {
|
|
t.Fatalf("error = %q, want substring %q", result.ForLLM, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ListFiltersJobsForRemoteChannel(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
everyMS := int64(60_000)
|
|
|
|
ownJob, err := tool.cronService.AddJob(
|
|
"own",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
"visible",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
otherChatJob, err := tool.cronService.AddJob(
|
|
"other-chat",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
"hidden",
|
|
"telegram",
|
|
"chat-2",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
otherChannelJob, err := tool.cronService.AddJob(
|
|
"other-channel",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
"hidden",
|
|
"feishu",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
commandJob, err := tool.cronService.AddJob(
|
|
"command",
|
|
cron.CronSchedule{Kind: "every", EveryMS: &everyMS},
|
|
"hidden command",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
commandJob.Payload.Command = "df -h"
|
|
if err := tool.cronService.UpdateJob(commandJob); err != nil {
|
|
t.Fatalf("UpdateJob() error: %v", err)
|
|
}
|
|
|
|
result := tool.Execute(ctx, map[string]any{"action": "list"})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("list failed: %s", result.ForLLM)
|
|
}
|
|
if !strings.Contains(result.ForLLM, ownJob.ID) {
|
|
t.Fatalf("list should include own job %s, got: %s", ownJob.ID, result.ForLLM)
|
|
}
|
|
for _, hiddenID := range []string{otherChatJob.ID, otherChannelJob.ID, commandJob.ID} {
|
|
if strings.Contains(result.ForLLM, hiddenID) {
|
|
t.Fatalf("list should not include hidden job %s, got: %s", hiddenID, result.ForLLM)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCronTool_RemoteCannotAccessOtherChatJob(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
job, err := tool.cronService.AddJob(
|
|
"private",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"secret",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-2")
|
|
|
|
getResult := tool.Execute(ctx, map[string]any{"action": "get", "job_id": job.ID})
|
|
if !getResult.IsError || !strings.Contains(getResult.ForLLM, "not accessible") {
|
|
t.Fatalf("expected inaccessible get, got: %+v", getResult)
|
|
}
|
|
|
|
updateResult := tool.Execute(ctx, map[string]any{"action": "update", "job_id": job.ID, "message": "changed"})
|
|
if !updateResult.IsError || !strings.Contains(updateResult.ForLLM, "not accessible") {
|
|
t.Fatalf("expected inaccessible update, got: %+v", updateResult)
|
|
}
|
|
unchanged, ok := tool.cronService.GetJob(job.ID)
|
|
if !ok {
|
|
t.Fatal("job should still exist")
|
|
}
|
|
if unchanged.Payload.Message != "secret" {
|
|
t.Fatalf("unauthorized update mutated job: %+v", unchanged.Payload)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_RemoteCannotAccessCommandJob(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
job, err := tool.cronService.AddJob(
|
|
"command",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"run command",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
job.Payload.Command = "df -h"
|
|
if err := tool.cronService.UpdateJob(job); err != nil {
|
|
t.Fatalf("UpdateJob() error: %v", err)
|
|
}
|
|
ctx := WithToolContext(context.Background(), "telegram", "chat-1")
|
|
|
|
getResult := tool.Execute(ctx, map[string]any{"action": "get", "job_id": job.ID})
|
|
if !getResult.IsError || !strings.Contains(getResult.ForLLM, "not accessible") {
|
|
t.Fatalf("expected inaccessible get, got: %+v", getResult)
|
|
}
|
|
|
|
updateResult := tool.Execute(ctx, map[string]any{"action": "update", "job_id": job.ID, "message": "changed"})
|
|
if !updateResult.IsError || !strings.Contains(updateResult.ForLLM, "not accessible") {
|
|
t.Fatalf("expected inaccessible update, got: %+v", updateResult)
|
|
}
|
|
unchanged, ok := tool.cronService.GetJob(job.ID)
|
|
if !ok {
|
|
t.Fatal("job should still exist")
|
|
}
|
|
if unchanged.Payload.Message != "run command" || unchanged.Payload.Command != "df -h" {
|
|
t.Fatalf("unauthorized update mutated command job: %+v", unchanged.Payload)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_CommandUpdateSafetyGates(t *testing.T) {
|
|
t.Run("exec disabled", func(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Exec.Enabled = false
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
job, err := tool.cronService.AddJob(
|
|
"job",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"message",
|
|
"cli",
|
|
"direct",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
})
|
|
|
|
if !result.IsError || !strings.Contains(result.ForLLM, "command execution is disabled") {
|
|
t.Fatalf("expected exec disabled error, got: %+v", result)
|
|
}
|
|
})
|
|
|
|
t.Run("confirm required", func(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Cron.AllowCommand = false
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
job, err := tool.cronService.AddJob(
|
|
"job",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"message",
|
|
"cli",
|
|
"direct",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
|
|
result := tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"command": "df -h",
|
|
})
|
|
|
|
if !result.IsError || !strings.Contains(result.ForLLM, "command_confirm=true") {
|
|
t.Fatalf("expected confirm error, got: %+v", result)
|
|
}
|
|
|
|
result = tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"command": "df -h",
|
|
"command_confirm": true,
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected confirmed command update to succeed, got: %s", result.ForLLM)
|
|
}
|
|
updated, _ := tool.cronService.GetJob(job.ID)
|
|
if updated.Payload.Command != "df -h" {
|
|
t.Fatalf("command not updated: %+v", updated.Payload)
|
|
}
|
|
|
|
result = tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"command": "",
|
|
"command_confirm": true,
|
|
})
|
|
|
|
if result.IsError {
|
|
t.Fatalf("expected empty command update to clear command, got: %s", result.ForLLM)
|
|
}
|
|
updated, _ = tool.cronService.GetJob(job.ID)
|
|
if updated.Payload.Command != "" {
|
|
t.Fatalf("command not cleared: %+v", updated.Payload)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCronTool_InternalCanAccessCommandJobFromAnyChannel(t *testing.T) {
|
|
tool := newTestCronTool(t)
|
|
ctx := WithToolContext(context.Background(), "cli", "direct")
|
|
job, err := tool.cronService.AddJob(
|
|
"command",
|
|
cron.CronSchedule{Kind: "cron", Expr: "0 8 * * *"},
|
|
"run command",
|
|
"telegram",
|
|
"chat-1",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("AddJob() error: %v", err)
|
|
}
|
|
job.Payload.Command = "df -h"
|
|
if err := tool.cronService.UpdateJob(job); err != nil {
|
|
t.Fatalf("UpdateJob() error: %v", err)
|
|
}
|
|
|
|
getResult := tool.Execute(ctx, map[string]any{"action": "get", "job_id": job.ID})
|
|
if getResult.IsError {
|
|
t.Fatalf("get failed: %s", getResult.ForLLM)
|
|
}
|
|
got := parseCronJobResult(t, getResult)
|
|
if got.Payload.Command != "df -h" || got.Payload.Channel != "telegram" || got.Payload.To != "chat-1" {
|
|
t.Fatalf("get returned wrong command job: %+v", got.Payload)
|
|
}
|
|
|
|
updateResult := tool.Execute(ctx, map[string]any{
|
|
"action": "update",
|
|
"job_id": job.ID,
|
|
"cron_expr": "30 10 * * *",
|
|
})
|
|
if updateResult.IsError {
|
|
t.Fatalf("update failed: %s", updateResult.ForLLM)
|
|
}
|
|
updated, _ := tool.cronService.GetJob(job.ID)
|
|
if updated.Payload.Command != "df -h" {
|
|
t.Fatalf("command should be preserved: %+v", updated.Payload)
|
|
}
|
|
if updated.Schedule.Kind != "cron" || updated.Schedule.Expr != "30 10 * * *" {
|
|
t.Fatalf("schedule not updated: %+v", updated.Schedule)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobPublishesErrorWhenExecDisabled(t *testing.T) {
|
|
cfg := config.DefaultConfig()
|
|
cfg.Tools.Exec.Enabled = false
|
|
|
|
tool := newTestCronToolWithConfig(t, cfg)
|
|
job := &cron.CronJob{}
|
|
job.Payload.Channel = "cli"
|
|
job.Payload.To = "direct"
|
|
job.Payload.Command = "df -h"
|
|
|
|
if got := tool.ExecuteJob(context.Background(), job); got != "ok" {
|
|
t.Fatalf("ExecuteJob() = %q, want ok", got)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
|
|
var msg bus.OutboundMessage
|
|
select {
|
|
case msg = <-tool.msgBus.OutboundChan():
|
|
// got message
|
|
case <-ctx.Done():
|
|
t.Fatal("timeout waiting for outbound message")
|
|
}
|
|
if !strings.Contains(msg.Content, "command execution is disabled") {
|
|
t.Fatalf("expected exec disabled message, got: %s", msg.Content)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobPublishesAgentResponse(t *testing.T) {
|
|
executor := &stubJobExecutor{response: "generated reply"}
|
|
tool := newTestCronToolWithExecutorAndConfig(t, executor, config.DefaultConfig())
|
|
|
|
job := &cron.CronJob{ID: "job-1"}
|
|
job.Payload.Channel = "telegram"
|
|
job.Payload.To = "chat-1"
|
|
job.Payload.Message = "send me a poem"
|
|
|
|
if got := tool.ExecuteJob(context.Background(), job); got != "ok" {
|
|
t.Fatalf("ExecuteJob() = %q, want ok", got)
|
|
}
|
|
|
|
if !strings.HasPrefix(executor.lastKey, "agent:cron-job-1-") {
|
|
t.Fatalf("sessionKey = %q, want agent:cron-job-1-{uuid}", executor.lastKey)
|
|
}
|
|
if executor.lastChan != "telegram" || executor.lastChatID != "chat-1" {
|
|
t.Fatalf("executor target = %s/%s, want telegram/chat-1", executor.lastChan, executor.lastChatID)
|
|
}
|
|
if executor.lastPrompt != "send me a poem" {
|
|
t.Fatalf("prompt = %q, want original message", executor.lastPrompt)
|
|
}
|
|
if executor.publishedResp != "generated reply" {
|
|
t.Fatalf("published response = %q, want generated reply", executor.publishedResp)
|
|
}
|
|
if executor.publishedKey != executor.lastKey {
|
|
t.Fatalf("published sessionKey = %q, want %q", executor.publishedKey, executor.lastKey)
|
|
}
|
|
if executor.publishedChan != "telegram" || executor.publishedChatID != "chat-1" {
|
|
t.Fatalf("published target = %s/%s, want telegram/chat-1", executor.publishedChan, executor.publishedChatID)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobSkipsEmptyAgentResponse(t *testing.T) {
|
|
executor := &stubJobExecutor{}
|
|
tool := newTestCronToolWithExecutorAndConfig(t, executor, config.DefaultConfig())
|
|
|
|
job := &cron.CronJob{ID: "job-empty"}
|
|
job.Payload.Channel = "telegram"
|
|
job.Payload.To = "chat-1"
|
|
job.Payload.Message = "say nothing"
|
|
|
|
if got := tool.ExecuteJob(context.Background(), job); got != "ok" {
|
|
t.Fatalf("ExecuteJob() = %q, want ok", got)
|
|
}
|
|
|
|
if executor.publishedResp != "" {
|
|
t.Fatalf("unexpected published response: %q", executor.publishedResp)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobSkipsWhenMessageToolAlreadySent(t *testing.T) {
|
|
executor := &stubJobExecutor{response: "Sent.", alreadySent: true}
|
|
tool := newTestCronToolWithExecutorAndConfig(t, executor, config.DefaultConfig())
|
|
|
|
job := &cron.CronJob{ID: "job-msg-sent"}
|
|
job.Payload.Channel = "telegram"
|
|
job.Payload.To = "chat-1"
|
|
job.Payload.Message = "send weather"
|
|
|
|
if got := tool.ExecuteJob(context.Background(), job); got != "ok" {
|
|
t.Fatalf("ExecuteJob() = %q, want ok", got)
|
|
}
|
|
|
|
if executor.publishedResp != "" {
|
|
t.Fatalf("expected no published response when message tool already sent, got: %q", executor.publishedResp)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobRunsCommand(t *testing.T) {
|
|
tool := newTestCronToolWithConfig(t, config.DefaultConfig())
|
|
job := &cron.CronJob{}
|
|
job.Payload.Channel = "cli"
|
|
job.Payload.To = "direct"
|
|
job.Payload.Command = "echo cron-test-ok"
|
|
|
|
if got := tool.ExecuteJob(context.Background(), job); got != "ok" {
|
|
t.Fatalf("ExecuteJob() = %q, want ok", got)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
|
|
var msg bus.OutboundMessage
|
|
select {
|
|
case msg = <-tool.msgBus.OutboundChan():
|
|
case <-ctx.Done():
|
|
t.Fatal("timeout waiting for outbound message")
|
|
}
|
|
if !strings.Contains(msg.Content, "cron-test-ok") {
|
|
t.Fatalf("expected command output containing 'cron-test-ok', got: %s", msg.Content)
|
|
}
|
|
}
|
|
|
|
func TestCronTool_ExecuteJobReturnsErrorWithoutPublish(t *testing.T) {
|
|
executor := &stubJobExecutor{
|
|
response: "this response must not be published",
|
|
err: fmt.Errorf("agent failure"),
|
|
}
|
|
tool := newTestCronToolWithExecutorAndConfig(t, executor, config.DefaultConfig())
|
|
|
|
job := &cron.CronJob{ID: "job-err"}
|
|
job.Payload.Channel = "telegram"
|
|
job.Payload.To = "chat-1"
|
|
job.Payload.Message = "do something"
|
|
|
|
got := tool.ExecuteJob(context.Background(), job)
|
|
if !strings.Contains(got, "agent failure") {
|
|
t.Fatalf("ExecuteJob() = %q, want error message", got)
|
|
}
|
|
|
|
if executor.publishedResp != "" {
|
|
t.Fatalf("unexpected publish on error path: %q", executor.publishedResp)
|
|
}
|
|
}
|