Compare commits
@@ -98,6 +98,11 @@ make lint # Run linters
|
||||
- modernc.org/sqlite (pure Go), migration 009_webhooks.sql (003-webhooks-k8s-runner)
|
||||
- Go 1.25+ (per go.mod) + mark3labs/mcp-go (MCP tools), go-chi/chi (HTTP), spf13/cobra (CLI), modernc.org/sqlite (storage), TFMV/hnsw (vectors) (004-embeddings-retention-inbox)
|
||||
- SQLite (modernc.org/sqlite, pure Go) — single DB file in `--data` directory (004-embeddings-retention-inbox)
|
||||
- Go 1.25+ (per go.mod) + spf13/cobra (CLI), go-chi/chi (HTTP), mark3labs/mcp-go (MCP) (006-admin-cli-docker-fixes)
|
||||
- modernc.org/sqlite (pure Go, zero CGO) (006-admin-cli-docker-fixes)
|
||||
- Go 1.25+ (per go.mod) + go-chi/chi (HTTP), mark3labs/mcp-go (MCP), ory/fosite (OAuth), spf13/cobra (CLI), modernc.org/sqlite (storage), TFMV/hnsw (vectors). NEW: coreos/go-oidc/v3 (OIDC), golang.org/x/oauth2 (OAuth client) (007-platform-features-bundle)
|
||||
- Go 1.25+ (backend), SvelteKit 2 + Svelte 5 (frontend), SvelteKit (website) + go-chi/chi (HTTP), mark3labs/mcp-go (MCP), modernc.org/sqlite (storage), SherClockHolmes/webpush-go (push notifications — NEW) (008-webui-pwa-analytics)
|
||||
- SQLite (existing DB, 1 new migration for push_subscriptions), localStorage (font size) (008-webui-pwa-analytics)
|
||||
|
||||
## Recent Changes
|
||||
- 002-mcp-auth-ux-polish: Added Go 1.23+ + ory/fosite (OAuth 2.1), mark3labs/mcp-go (MCP server), go-chi/chi (HTTP), Svelte 5 + Tailwind (Web UI)
|
||||
|
||||
+2
-3
@@ -18,9 +18,8 @@ COPY --from=web-builder /app/web/build internal/web/dist/
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w -X main.version=${VERSION}" -o /synapbus ./cmd/synapbus/
|
||||
|
||||
# Stage 3: Runtime
|
||||
FROM scratch
|
||||
COPY --from=go-builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
|
||||
COPY --from=go-builder /usr/share/zoneinfo /usr/share/zoneinfo
|
||||
FROM alpine:3.19
|
||||
RUN apk add --no-cache ca-certificates tzdata && touch /.dockerenv
|
||||
COPY --from=go-builder /synapbus /synapbus
|
||||
EXPOSE 8080
|
||||
VOLUME ["/data"]
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
# Autonomous Execution Summary: SynapBus v0.7.0
|
||||
|
||||
**Date**: 2026-03-17
|
||||
**Branch**: `008-webui-pwa-analytics`
|
||||
**Status**: Complete — all tests pass, binary builds, endpoints verified
|
||||
|
||||
## Features Implemented
|
||||
|
||||
### 1. Analytics Dashboard (P1)
|
||||
- 4 new REST endpoints (`/api/analytics/timeline`, `/top-agents`, `/top-channels`, `/summary`)
|
||||
- SVG bar chart (`AnalyticsChart.svelte`), ranked list (`TopList.svelte`), redesigned dashboard with stat cards and time span selector (1h, 4h, 24h, 7d, 1month)
|
||||
|
||||
### 2. PWA Conversion (P1)
|
||||
- PWA manifest (`manifest.json`), service worker (`sw.js`), SVG icon
|
||||
- Cache-first for static assets, network-only for API, push notification handling
|
||||
|
||||
### 3. Push Notifications (P1)
|
||||
- `internal/push/` package — VAPID key generation, Web Push sending, SQLite subscription store
|
||||
- API: `POST/DELETE /api/push/subscribe`, `GET /api/push/vapid-key`
|
||||
- Push toggle in Settings, migration `012_push_subscriptions.sql`
|
||||
|
||||
### 4. Auto-Resizing Textarea (P1)
|
||||
- ComposeForm textarea auto-grows 3→12 lines, then scrollbar. Resets on send.
|
||||
|
||||
### 5. Smart Mention/Channel Highlighting (P2)
|
||||
- Entities store caches agents/channels. MessageBody validates @mentions and #channels:
|
||||
existing → link, deleted → "inactive" badge, unknown → plain text. Handles email/issue number edge cases.
|
||||
|
||||
### 6. Editable Agent Display Name (P2)
|
||||
- Inline edit on agent detail page (click → edit, Enter → save, Escape → cancel)
|
||||
|
||||
### 7. Editable Human Display Name (P2)
|
||||
- `PUT /api/auth/profile` endpoint, `UpdateDisplayName` in UserStore, Settings page field
|
||||
|
||||
### 8. Font Size Preference (P3)
|
||||
- fontSize store (12–24px, 2px steps), -/+ controls in Settings, persisted in localStorage
|
||||
|
||||
### 9. Version Display (P3)
|
||||
- `GET /api/version` endpoint, version footer in layout linked to GitHub repo
|
||||
|
||||
### 10. MCP Prompts (P2)
|
||||
- 4 prompts: daily-digest, agent-health-check, channel-overview, debug-agent
|
||||
- `internal/mcp/prompts.go` registered in server.go
|
||||
|
||||
### 11. Website Update (P3)
|
||||
- Updated hero/features messaging at ~/repos/synapbus-website/ for individual/small-team positioning
|
||||
|
||||
## Test Results
|
||||
|
||||
All 24 Go packages PASS. All API endpoints verified via curl. Web UI builds successfully. Binary compiles with CGO_ENABLED=0.
|
||||
|
||||
## New Files
|
||||
|
||||
- `internal/api/analytics_handler.go` + test
|
||||
- `internal/api/version_handler.go` + test
|
||||
- `internal/api/push_handler.go`
|
||||
- `internal/push/service.go` + test, `store.go` + test
|
||||
- `internal/mcp/prompts.go` + test
|
||||
- `schema/012_push_subscriptions.sql`
|
||||
- `web/src/lib/components/AnalyticsChart.svelte`, `TopList.svelte`
|
||||
- `web/src/lib/stores/fontSize.ts`, `entities.ts`
|
||||
- `web/static/manifest.json`, `sw.js`, `icons/icon.svg`
|
||||
+290
-6
@@ -17,7 +17,7 @@ var adminSocket string
|
||||
// adminRequest sends a command over the Unix socket and returns the parsed response.
|
||||
func adminRequest(command string, args interface{}) (map[string]interface{}, error) {
|
||||
socket := adminSocket
|
||||
if s := os.Getenv("SYNAPBUS_SOCKET"); s != "" && socket == "./data/synapbus.sock" {
|
||||
if s := os.Getenv("SYNAPBUS_SOCKET"); s != "" && socket == "/tmp/synapbus.sock" {
|
||||
socket = s
|
||||
}
|
||||
|
||||
@@ -308,7 +308,31 @@ func addAdminCommands(rootCmd *cobra.Command) {
|
||||
agentRevokeKeyCmd.Flags().StringVar(&agentRevokeKeyName, "name", "", "Agent name")
|
||||
agentRevokeKeyCmd.MarkFlagRequired("name")
|
||||
|
||||
agentCmd.AddCommand(agentListCmd, agentCreateCmd, agentDeleteCmd, agentRevokeKeyCmd)
|
||||
var (
|
||||
agentUpdateCapsName string
|
||||
agentUpdateCapsJSON string
|
||||
)
|
||||
agentUpdateCapsCmd := &cobra.Command{
|
||||
Use: "update-capabilities",
|
||||
Short: "Update an agent's capabilities JSON",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("agent.update_capabilities", map[string]interface{}{
|
||||
"name": agentUpdateCapsName,
|
||||
"capabilities": json.RawMessage(agentUpdateCapsJSON),
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
agentUpdateCapsCmd.Flags().StringVar(&agentUpdateCapsName, "name", "", "Agent name")
|
||||
agentUpdateCapsCmd.Flags().StringVar(&agentUpdateCapsJSON, "capabilities", "", "Capabilities JSON (e.g. '{\"role\":\"researcher\"}')")
|
||||
agentUpdateCapsCmd.MarkFlagRequired("name")
|
||||
agentUpdateCapsCmd.MarkFlagRequired("capabilities")
|
||||
|
||||
agentCmd.AddCommand(agentListCmd, agentCreateCmd, agentDeleteCmd, agentRevokeKeyCmd, agentUpdateCapsCmd)
|
||||
|
||||
// ----- audit commands -----
|
||||
auditCmd := &cobra.Command{
|
||||
@@ -561,7 +585,54 @@ func addAdminCommands(rootCmd *cobra.Command) {
|
||||
channelsShowCmd.Flags().StringVar(&channelsShowName, "name", "", "Channel name")
|
||||
channelsShowCmd.MarkFlagRequired("name")
|
||||
|
||||
channelsCmd.AddCommand(channelsListCmd, channelsShowCmd)
|
||||
var (
|
||||
channelsCreateName string
|
||||
channelsCreateDesc string
|
||||
)
|
||||
channelsCreateCmd := &cobra.Command{
|
||||
Use: "create",
|
||||
Short: "Create a new channel",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("channels.create", map[string]string{
|
||||
"name": channelsCreateName,
|
||||
"description": channelsCreateDesc,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
channelsCreateCmd.Flags().StringVar(&channelsCreateName, "name", "", "Channel name")
|
||||
channelsCreateCmd.Flags().StringVar(&channelsCreateDesc, "description", "", "Channel description")
|
||||
channelsCreateCmd.MarkFlagRequired("name")
|
||||
|
||||
var (
|
||||
channelsJoinChannel string
|
||||
channelsJoinAgent string
|
||||
)
|
||||
channelsJoinCmd := &cobra.Command{
|
||||
Use: "join",
|
||||
Short: "Add an agent to a channel",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("channels.join", map[string]string{
|
||||
"channel": channelsJoinChannel,
|
||||
"agent": channelsJoinAgent,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
channelsJoinCmd.Flags().StringVar(&channelsJoinChannel, "channel", "", "Channel name")
|
||||
channelsJoinCmd.Flags().StringVar(&channelsJoinAgent, "agent", "", "Agent name")
|
||||
channelsJoinCmd.MarkFlagRequired("channel")
|
||||
channelsJoinCmd.MarkFlagRequired("agent")
|
||||
|
||||
channelsCmd.AddCommand(channelsListCmd, channelsShowCmd, channelsCreateCmd, channelsJoinCmd)
|
||||
|
||||
// ----- conversations commands -----
|
||||
conversationsCmd := &cobra.Command{
|
||||
@@ -705,10 +776,223 @@ func addAdminCommands(rootCmd *cobra.Command) {
|
||||
|
||||
retentionCmd.AddCommand(retentionStatusCmd)
|
||||
|
||||
// ----- add persistent flag and commands to root -----
|
||||
rootCmd.PersistentFlags().StringVar(&adminSocket, "socket", "./data/synapbus.sock", "Path to admin Unix socket")
|
||||
// ----- webhook commands -----
|
||||
webhookCmd := &cobra.Command{
|
||||
Use: "webhook",
|
||||
Short: "Manage webhooks",
|
||||
}
|
||||
|
||||
rootCmd.AddCommand(userCmd, agentCmd, auditCmd, backupCmd, messagesCmd, channelsCmd, conversationsCmd, embeddingsCmd, dbCmd, retentionCmd)
|
||||
var (
|
||||
webhookRegisterURL string
|
||||
webhookRegisterEvents string
|
||||
webhookRegisterSecret string
|
||||
webhookRegisterAgent string
|
||||
)
|
||||
webhookRegisterCmd := &cobra.Command{
|
||||
Use: "register",
|
||||
Short: "Register a webhook",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("webhook.register", map[string]string{
|
||||
"url": webhookRegisterURL,
|
||||
"events": webhookRegisterEvents,
|
||||
"secret": webhookRegisterSecret,
|
||||
"agent_name": webhookRegisterAgent,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
webhookRegisterCmd.Flags().StringVar(&webhookRegisterURL, "url", "", "Webhook endpoint URL")
|
||||
webhookRegisterCmd.Flags().StringVar(&webhookRegisterEvents, "events", "", "Comma-separated event types (e.g. message.received,channel.message)")
|
||||
webhookRegisterCmd.Flags().StringVar(&webhookRegisterSecret, "secret", "", "HMAC signing secret")
|
||||
webhookRegisterCmd.Flags().StringVar(&webhookRegisterAgent, "agent", "", "Agent name to hook events for")
|
||||
webhookRegisterCmd.MarkFlagRequired("url")
|
||||
webhookRegisterCmd.MarkFlagRequired("events")
|
||||
webhookRegisterCmd.MarkFlagRequired("secret")
|
||||
webhookRegisterCmd.MarkFlagRequired("agent")
|
||||
|
||||
var webhookListAgent string
|
||||
webhookListCmd := &cobra.Command{
|
||||
Use: "list",
|
||||
Short: "List webhooks",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
reqArgs := map[string]interface{}{}
|
||||
if webhookListAgent != "" {
|
||||
reqArgs["agent_name"] = webhookListAgent
|
||||
}
|
||||
resp, err := adminRequest("webhook.list", reqArgs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rows := toMapSlice(resp["data"])
|
||||
if len(rows) == 0 {
|
||||
fmt.Println("No webhooks found.")
|
||||
return nil
|
||||
}
|
||||
printTable([]string{"ID", "AGENT", "URL", "EVENTS", "STATUS", "FAILURES", "CREATED_AT"}, toTableRows(rows, map[string]string{
|
||||
"ID": "id", "AGENT": "agent_name", "URL": "url", "EVENTS": "events",
|
||||
"STATUS": "status", "FAILURES": "consecutive_failures", "CREATED_AT": "created_at",
|
||||
}))
|
||||
return nil
|
||||
},
|
||||
}
|
||||
webhookListCmd.Flags().StringVar(&webhookListAgent, "agent", "", "Filter by agent name")
|
||||
|
||||
var webhookDeleteID int64
|
||||
webhookDeleteCmd := &cobra.Command{
|
||||
Use: "delete",
|
||||
Short: "Delete a webhook",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("webhook.delete", map[string]interface{}{
|
||||
"id": webhookDeleteID,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
webhookDeleteCmd.Flags().Int64Var(&webhookDeleteID, "id", 0, "Webhook ID to delete")
|
||||
webhookDeleteCmd.MarkFlagRequired("id")
|
||||
|
||||
webhookCmd.AddCommand(webhookRegisterCmd, webhookListCmd, webhookDeleteCmd)
|
||||
|
||||
// ----- k8s commands -----
|
||||
k8sCmd := &cobra.Command{
|
||||
Use: "k8s",
|
||||
Short: "Manage Kubernetes job handlers",
|
||||
}
|
||||
|
||||
var (
|
||||
k8sRegisterImage string
|
||||
k8sRegisterEvents string
|
||||
k8sRegisterAgent string
|
||||
k8sRegisterNamespace string
|
||||
k8sRegisterMemory string
|
||||
k8sRegisterCPU string
|
||||
k8sRegisterEnv string
|
||||
k8sRegisterTimeout int
|
||||
)
|
||||
k8sRegisterCmd := &cobra.Command{
|
||||
Use: "register",
|
||||
Short: "Register a K8s job handler",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
reqArgs := map[string]interface{}{
|
||||
"image": k8sRegisterImage,
|
||||
"events": k8sRegisterEvents,
|
||||
"agent_name": k8sRegisterAgent,
|
||||
}
|
||||
if k8sRegisterNamespace != "" {
|
||||
reqArgs["namespace"] = k8sRegisterNamespace
|
||||
}
|
||||
if k8sRegisterMemory != "" {
|
||||
reqArgs["resources_memory"] = k8sRegisterMemory
|
||||
}
|
||||
if k8sRegisterCPU != "" {
|
||||
reqArgs["resources_cpu"] = k8sRegisterCPU
|
||||
}
|
||||
if k8sRegisterEnv != "" {
|
||||
reqArgs["env"] = k8sRegisterEnv
|
||||
}
|
||||
if k8sRegisterTimeout > 0 {
|
||||
reqArgs["timeout_seconds"] = k8sRegisterTimeout
|
||||
}
|
||||
resp, err := adminRequest("k8s.register", reqArgs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterImage, "image", "", "Container image")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterEvents, "events", "", "Comma-separated event types")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterAgent, "agent", "", "Agent name")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterNamespace, "namespace", "", "Kubernetes namespace (optional)")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterMemory, "memory", "", "Memory resource limit (e.g. 256Mi)")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterCPU, "cpu", "", "CPU resource limit (e.g. 500m)")
|
||||
k8sRegisterCmd.Flags().StringVar(&k8sRegisterEnv, "env", "", "Comma-separated KEY=VALUE environment variables")
|
||||
k8sRegisterCmd.Flags().IntVar(&k8sRegisterTimeout, "timeout", 300, "Job timeout in seconds")
|
||||
k8sRegisterCmd.MarkFlagRequired("image")
|
||||
k8sRegisterCmd.MarkFlagRequired("events")
|
||||
k8sRegisterCmd.MarkFlagRequired("agent")
|
||||
|
||||
var k8sListAgent string
|
||||
k8sListCmd := &cobra.Command{
|
||||
Use: "list",
|
||||
Short: "List K8s job handlers",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
reqArgs := map[string]interface{}{}
|
||||
if k8sListAgent != "" {
|
||||
reqArgs["agent_name"] = k8sListAgent
|
||||
}
|
||||
resp, err := adminRequest("k8s.list", reqArgs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rows := toMapSlice(resp["data"])
|
||||
if len(rows) == 0 {
|
||||
fmt.Println("No K8s handlers found.")
|
||||
return nil
|
||||
}
|
||||
printTable([]string{"ID", "AGENT", "IMAGE", "EVENTS", "NAMESPACE", "STATUS", "CREATED_AT"}, toTableRows(rows, map[string]string{
|
||||
"ID": "id", "AGENT": "agent_name", "IMAGE": "image", "EVENTS": "events",
|
||||
"NAMESPACE": "namespace", "STATUS": "status", "CREATED_AT": "created_at",
|
||||
}))
|
||||
return nil
|
||||
},
|
||||
}
|
||||
k8sListCmd.Flags().StringVar(&k8sListAgent, "agent", "", "Filter by agent name")
|
||||
|
||||
var k8sDeleteID int64
|
||||
k8sDeleteCmd := &cobra.Command{
|
||||
Use: "delete",
|
||||
Short: "Delete a K8s job handler",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("k8s.delete", map[string]interface{}{
|
||||
"id": k8sDeleteID,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
k8sDeleteCmd.Flags().Int64Var(&k8sDeleteID, "id", 0, "Handler ID to delete")
|
||||
k8sDeleteCmd.MarkFlagRequired("id")
|
||||
|
||||
k8sCmd.AddCommand(k8sRegisterCmd, k8sListCmd, k8sDeleteCmd)
|
||||
|
||||
// ----- attachments commands -----
|
||||
attachmentsCmd := &cobra.Command{
|
||||
Use: "attachments",
|
||||
Short: "Manage attachments",
|
||||
}
|
||||
|
||||
attachmentsGCCmd := &cobra.Command{
|
||||
Use: "gc",
|
||||
Short: "Run attachment garbage collection to remove orphaned files",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
resp, err := adminRequest("attachments.gc", nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printJSON(resp["data"])
|
||||
return nil
|
||||
},
|
||||
}
|
||||
|
||||
attachmentsCmd.AddCommand(attachmentsGCCmd)
|
||||
|
||||
// ----- add persistent flag and commands to root -----
|
||||
rootCmd.PersistentFlags().StringVar(&adminSocket, "socket", "/tmp/synapbus.sock", "Path to admin Unix socket")
|
||||
|
||||
rootCmd.AddCommand(userCmd, agentCmd, auditCmd, backupCmd, messagesCmd, channelsCmd, conversationsCmd, embeddingsCmd, dbCmd, retentionCmd, webhookCmd, k8sCmd, attachmentsCmd)
|
||||
}
|
||||
|
||||
// toTableRows remaps []map[string]string using a header->key mapping.
|
||||
|
||||
@@ -0,0 +1,289 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
// findSubcommand finds a subcommand by name in a cobra.Command tree.
|
||||
func findSubcommand(root *cobra.Command, names ...string) *cobra.Command {
|
||||
cmd := root
|
||||
for _, name := range names {
|
||||
found := false
|
||||
for _, sub := range cmd.Commands() {
|
||||
if sub.Name() == name {
|
||||
cmd = sub
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return cmd
|
||||
}
|
||||
|
||||
// buildTestRoot creates a root command with all admin commands registered.
|
||||
func buildTestRoot() *cobra.Command {
|
||||
root := &cobra.Command{Use: "synapbus"}
|
||||
addAdminCommands(root)
|
||||
return root
|
||||
}
|
||||
|
||||
func TestWebhookCommandsRegistered(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
|
||||
tests := []struct {
|
||||
path []string
|
||||
}{
|
||||
{[]string{"webhook"}},
|
||||
{[]string{"webhook", "register"}},
|
||||
{[]string{"webhook", "list"}},
|
||||
{[]string{"webhook", "delete"}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
cmd := findSubcommand(root, tt.path...)
|
||||
if cmd == nil {
|
||||
t.Errorf("command %v not found", tt.path)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestK8sCommandsRegistered(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
|
||||
tests := []struct {
|
||||
path []string
|
||||
}{
|
||||
{[]string{"k8s"}},
|
||||
{[]string{"k8s", "register"}},
|
||||
{[]string{"k8s", "list"}},
|
||||
{[]string{"k8s", "delete"}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
cmd := findSubcommand(root, tt.path...)
|
||||
if cmd == nil {
|
||||
t.Errorf("command %v not found", tt.path)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAttachmentsCommandsRegistered(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
|
||||
tests := []struct {
|
||||
path []string
|
||||
}{
|
||||
{[]string{"attachments"}},
|
||||
{[]string{"attachments", "gc"}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
cmd := findSubcommand(root, tt.path...)
|
||||
if cmd == nil {
|
||||
t.Errorf("command %v not found", tt.path)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestWebhookRegisterRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "webhook", "register")
|
||||
if cmd == nil {
|
||||
t.Fatal("webhook register command not found")
|
||||
}
|
||||
|
||||
requiredFlags := []string{"url", "events", "secret", "agent"}
|
||||
for _, flag := range requiredFlags {
|
||||
f := cmd.Flag(flag)
|
||||
if f == nil {
|
||||
t.Errorf("flag --%s not found on webhook register", flag)
|
||||
continue
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
continue
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestWebhookDeleteRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "webhook", "delete")
|
||||
if cmd == nil {
|
||||
t.Fatal("webhook delete command not found")
|
||||
}
|
||||
|
||||
f := cmd.Flag("id")
|
||||
if f == nil {
|
||||
t.Fatal("flag --id not found on webhook delete")
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Fatal("flag --id should be required")
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Fatal("flag --id should be required")
|
||||
}
|
||||
}
|
||||
|
||||
func TestK8sRegisterRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "k8s", "register")
|
||||
if cmd == nil {
|
||||
t.Fatal("k8s register command not found")
|
||||
}
|
||||
|
||||
requiredFlags := []string{"image", "events", "agent"}
|
||||
for _, flag := range requiredFlags {
|
||||
f := cmd.Flag(flag)
|
||||
if f == nil {
|
||||
t.Errorf("flag --%s not found on k8s register", flag)
|
||||
continue
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
continue
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestK8sDeleteRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "k8s", "delete")
|
||||
if cmd == nil {
|
||||
t.Fatal("k8s delete command not found")
|
||||
}
|
||||
|
||||
f := cmd.Flag("id")
|
||||
if f == nil {
|
||||
t.Fatal("flag --id not found on k8s delete")
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Fatal("flag --id should be required")
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Fatal("flag --id should be required")
|
||||
}
|
||||
}
|
||||
|
||||
func TestK8sRegisterOptionalFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "k8s", "register")
|
||||
if cmd == nil {
|
||||
t.Fatal("k8s register command not found")
|
||||
}
|
||||
|
||||
optionalFlags := []string{"namespace", "memory", "cpu", "env", "timeout"}
|
||||
for _, flag := range optionalFlags {
|
||||
f := cmd.Flag(flag)
|
||||
if f == nil {
|
||||
t.Errorf("optional flag --%s not found on k8s register", flag)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelsCreateCommandRegistered(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "channels", "create")
|
||||
if cmd == nil {
|
||||
t.Fatal("channels create command not found")
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelsCreateRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "channels", "create")
|
||||
if cmd == nil {
|
||||
t.Fatal("channels create command not found")
|
||||
}
|
||||
|
||||
// --name is required
|
||||
f := cmd.Flag("name")
|
||||
if f == nil {
|
||||
t.Fatal("flag --name not found on channels create")
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Fatal("flag --name should be required")
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Fatal("flag --name should be required")
|
||||
}
|
||||
|
||||
// --description is optional
|
||||
df := cmd.Flag("description")
|
||||
if df == nil {
|
||||
t.Fatal("flag --description not found on channels create")
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelsJoinCommandRegistered(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "channels", "join")
|
||||
if cmd == nil {
|
||||
t.Fatal("channels join command not found")
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelsJoinRequiredFlags(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
cmd := findSubcommand(root, "channels", "join")
|
||||
if cmd == nil {
|
||||
t.Fatal("channels join command not found")
|
||||
}
|
||||
|
||||
requiredFlags := []string{"channel", "agent"}
|
||||
for _, flag := range requiredFlags {
|
||||
f := cmd.Flag(flag)
|
||||
if f == nil {
|
||||
t.Errorf("flag --%s not found on channels join", flag)
|
||||
continue
|
||||
}
|
||||
ann := f.Annotations
|
||||
if ann == nil {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
continue
|
||||
}
|
||||
if _, ok := ann[cobra.BashCompOneRequiredFlag]; !ok {
|
||||
t.Errorf("flag --%s should be required", flag)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultSocketPath(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
f := root.PersistentFlags().Lookup("socket")
|
||||
if f == nil {
|
||||
t.Fatal("--socket persistent flag not found")
|
||||
}
|
||||
if f.DefValue != "/tmp/synapbus.sock" {
|
||||
t.Errorf("default socket path = %q, want %q", f.DefValue, "/tmp/synapbus.sock")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExistingCommandsStillPresent(t *testing.T) {
|
||||
root := buildTestRoot()
|
||||
|
||||
// Verify existing commands are not broken by our additions.
|
||||
existingCmds := []string{"user", "agent", "audit", "backup", "messages", "channels", "conversations", "embeddings", "db", "retention"}
|
||||
for _, name := range existingCmds {
|
||||
cmd := findSubcommand(root, name)
|
||||
if cmd == nil {
|
||||
t.Errorf("existing command %q not found after adding new commands", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
+156
-5
@@ -23,16 +23,20 @@ import (
|
||||
"github.com/prometheus/client_golang/prometheus/promhttp"
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/a2a"
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/admin"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/api"
|
||||
"github.com/synapbus/synapbus/internal/apikeys"
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
"github.com/synapbus/synapbus/internal/auth"
|
||||
"github.com/synapbus/synapbus/internal/auth/idp"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/console"
|
||||
"github.com/synapbus/synapbus/internal/dispatcher"
|
||||
"github.com/synapbus/synapbus/internal/health"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
k8spkg "github.com/synapbus/synapbus/internal/k8s"
|
||||
mcpserver "github.com/synapbus/synapbus/internal/mcp"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
@@ -40,6 +44,7 @@ import (
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
"github.com/synapbus/synapbus/internal/search/embedding"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
"github.com/synapbus/synapbus/internal/push"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
"github.com/synapbus/synapbus/internal/web"
|
||||
"github.com/synapbus/synapbus/internal/webhooks"
|
||||
@@ -159,7 +164,13 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
messageRetention = mr
|
||||
}
|
||||
if adminSocketPath == "" {
|
||||
adminSocketPath = filepath.Join(dataDir, "synapbus.sock")
|
||||
// Default to /tmp in containers — PVC-backed filesystems (NFS, Ceph,
|
||||
// EBS CSI) often don't support Unix domain sockets.
|
||||
if _, err := os.Stat("/.dockerenv"); err == nil {
|
||||
adminSocketPath = "/tmp/synapbus.sock"
|
||||
} else {
|
||||
adminSocketPath = filepath.Join(dataDir, "synapbus.sock")
|
||||
}
|
||||
}
|
||||
|
||||
// Configure slog with JSON handler writing to stderr (stdout is for console output)
|
||||
@@ -297,6 +308,13 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
// Wire agent lister into auth handlers for OAuth authorize page
|
||||
authHandlers.SetAgentLister(&agentListerAdapter{agentService: agentService})
|
||||
|
||||
// Initialize external identity providers (GitHub, Google, Azure AD)
|
||||
baseURL := authCfg.IssuerURL
|
||||
if baseURL == "" {
|
||||
baseURL = fmt.Sprintf("http://localhost:%d", port)
|
||||
}
|
||||
idpProviders := idp.LoadConfig(baseURL)
|
||||
|
||||
// Register default MCP OAuth client if it doesn't already exist (T016)
|
||||
ensureDefaultMCPClient(ctx, db.DB, authCfg.BcryptCost)
|
||||
|
||||
@@ -387,6 +405,9 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
embPipeline = search.NewPipeline(embProvider, embStore, vectorIndex, searchCfg)
|
||||
embPipeline.Start(ctx)
|
||||
|
||||
// Wire pipeline into messaging so new messages auto-enqueue
|
||||
msgService.SetEmbeddingNotifier(embPipeline)
|
||||
|
||||
// Create search service with semantic support
|
||||
searchService = search.NewService(db.DB, embProvider, vectorIndex, msgService)
|
||||
slog.Info("semantic search enabled",
|
||||
@@ -423,7 +444,7 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
// Create K8s job runner and service
|
||||
k8sRunner := k8spkg.NewJobRunner(slog.Default())
|
||||
k8sStore := k8spkg.NewSQLiteK8sStore(db.DB)
|
||||
k8sService := k8spkg.NewK8sService(k8sStore, k8sRunner)
|
||||
k8sService := k8spkg.NewK8sService(k8sStore, k8sRunner) // K8s service for CLI admin commands; not passed to MCP
|
||||
k8sDispatcher := k8spkg.NewK8sDispatcher(k8sStore, k8sRunner, slog.Default())
|
||||
|
||||
if k8sRunner.IsAvailable() {
|
||||
@@ -436,8 +457,15 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
eventDispatcher := dispatcher.NewMultiDispatcher(slog.Default(), deliveryEngine, k8sDispatcher)
|
||||
msgService.SetDispatcher(eventDispatcher)
|
||||
|
||||
// Create MCP server (with swarm + attachment + search + webhook + K8s tools)
|
||||
mcpSrv := mcpserver.NewMCPServer(msgService, agentService, channelService, swarmService, attachmentService, searchService, con, webhookService, k8sService, db.DB)
|
||||
// Create JS runtime pool and action registry for hybrid MCP tools
|
||||
jsPool := jsruntime.NewPool(10)
|
||||
defer jsPool.Close()
|
||||
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
// Create MCP server (4 hybrid tools: my_status, send_message, search, execute)
|
||||
mcpSrv := mcpserver.NewMCPServer(msgService, agentService, channelService, swarmService, attachmentService, searchService, con, jsPool, actionRegistry, actionIndex, db.DB)
|
||||
startTime := time.Now()
|
||||
|
||||
// Start task expiry worker
|
||||
@@ -459,6 +487,17 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
slog.Info("message retention disabled")
|
||||
}
|
||||
|
||||
// Start stalemate worker (message acknowledgment enforcement)
|
||||
stalemateConfig := messaging.ParseStalemateConfig()
|
||||
stalemateWorker := messaging.NewStalemateWorker(db.DB, msgService, &channelLookupAdapter{channelService: channelService}, stalemateConfig)
|
||||
stalemateWorker.Start()
|
||||
slog.Info("stalemate worker started",
|
||||
"processing_timeout", stalemateConfig.ProcessingTimeout.String(),
|
||||
"reminder_after", stalemateConfig.ReminderAfter.String(),
|
||||
"escalate_after", stalemateConfig.EscalateAfter.String(),
|
||||
"interval", stalemateConfig.Interval.String(),
|
||||
)
|
||||
|
||||
// Create health checker
|
||||
healthChecker := health.NewChecker(db.DB, version)
|
||||
|
||||
@@ -496,9 +535,34 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
r.Post("/auth/register", withHumanAgent(authHandlers.HandleRegister, userStore, agentService, channelService))
|
||||
r.Post("/auth/login", withHumanAgent(authHandlers.HandleLogin, userStore, agentService, channelService))
|
||||
|
||||
// External identity provider endpoints (public)
|
||||
if len(idpProviders) > 0 {
|
||||
idpStore := idp.NewUserIdentityStore(db.DB)
|
||||
idpAgentAdapter := &idpAgentProvisioner{agentService: agentService, channelService: channelService}
|
||||
idpHandlers := idp.NewHandlers(idpProviders, idpStore, userStore, sessionStore, idpAgentAdapter)
|
||||
r.Get("/auth/providers", idpHandlers.HandleListProviders)
|
||||
r.Get("/auth/login/{provider}", idpHandlers.HandleLogin)
|
||||
r.Get("/auth/callback/{provider}", idpHandlers.HandleCallback)
|
||||
slog.Info("external identity providers configured", "count", len(idpProviders))
|
||||
} else {
|
||||
// Return empty list when no providers configured
|
||||
r.Get("/auth/providers", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Write([]byte(`{"providers":[]}`))
|
||||
})
|
||||
}
|
||||
|
||||
// OAuth metadata (public, per RFC 8414)
|
||||
r.Get("/.well-known/oauth-authorization-server", authHandlers.HandleOAuthMetadata)
|
||||
|
||||
// A2A Agent Card discovery (public, no auth required)
|
||||
agentCardBaseURL := authCfg.IssuerURL // reuse the same base URL config
|
||||
r.Get("/.well-known/agent-card.json", a2a.NewAgentCardHandler(
|
||||
&a2aAgentListerAdapter{agentService: agentService},
|
||||
agentCardBaseURL,
|
||||
version,
|
||||
))
|
||||
|
||||
// OAuth endpoints
|
||||
r.Get("/oauth/authorize", authHandlers.HandleAuthorizeGet)
|
||||
r.Post("/oauth/authorize", authHandlers.HandleAuthorizePost)
|
||||
@@ -512,6 +576,7 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
r.Post("/auth/logout", authHandlers.HandleLogout)
|
||||
r.Get("/auth/me", authHandlers.HandleMe)
|
||||
r.Put("/auth/password", authHandlers.HandleChangePassword)
|
||||
r.Put("/api/auth/profile", authHandlers.HandleUpdateProfile)
|
||||
})
|
||||
|
||||
// MCP Streamable HTTP endpoint (requires agent auth: API key, managed key, or OAuth bearer)
|
||||
@@ -520,8 +585,28 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
r.Mount("/mcp", mcpSrv.Handler())
|
||||
})
|
||||
|
||||
// Create SSE hub for real-time events
|
||||
// A2A Gateway (requires auth: API key, managed key, or OAuth bearer)
|
||||
a2aTaskStore := a2a.NewA2ATaskStore(db.DB)
|
||||
a2aGateway := a2a.NewGateway(a2aTaskStore, msgService, agentService)
|
||||
r.Group(func(r chi.Router) {
|
||||
r.Use(agents.RequiredAuthMiddlewareWithOAuth(agentService, apiKeyService, oauthProvider))
|
||||
r.Post("/a2a", a2aGateway.HandleJSONRPC)
|
||||
})
|
||||
|
||||
// Create SSE hub and broadcaster for real-time events
|
||||
sseHub := api.NewSSEHub()
|
||||
sseBroadcaster := api.NewSSEBroadcaster(sseHub, agentService, channelService)
|
||||
|
||||
// Register broadcaster as a message listener so SSE events fire
|
||||
// for messages sent via MCP (agents) as well as the REST API.
|
||||
msgService.AddMessageListener(sseBroadcaster)
|
||||
|
||||
// Initialize push notification service
|
||||
pushStore := push.NewSQLiteStore(db.DB)
|
||||
pushService, err := push.NewService(pushStore, dataDir, logger)
|
||||
if err != nil {
|
||||
logger.Warn("push notification service unavailable", "error", err)
|
||||
}
|
||||
|
||||
// Mount API routes (traces, export, stats, metrics, attachments, messages, agents, channels, SSE)
|
||||
sessionMiddleware := api.SessionToOwnerMiddleware(userStore, sessionStore)
|
||||
@@ -535,7 +620,11 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
APIKeyService: apiKeyService,
|
||||
DeadLetterStore: deadLetterStore,
|
||||
SSEHub: sseHub,
|
||||
Broadcaster: sseBroadcaster,
|
||||
SessionMiddleware: sessionMiddleware,
|
||||
DB: db.DB,
|
||||
Version: version,
|
||||
PushService: pushService,
|
||||
})
|
||||
r.Mount("/", apiRouter)
|
||||
|
||||
@@ -564,6 +653,8 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
if retentionWorker != nil {
|
||||
adminSvcs.RetentionWorker = retentionWorker
|
||||
}
|
||||
adminSvcs.WebhookService = webhookService
|
||||
adminSvcs.K8sService = k8sService
|
||||
adminServer := admin.NewServer(adminSocketPath, db.DB, adminSvcs, logger)
|
||||
if err := adminServer.Start(); err != nil {
|
||||
return fmt.Errorf("start admin socket: %w", err)
|
||||
@@ -622,6 +713,9 @@ func runServe(cmd *cobra.Command, args []string) error {
|
||||
retentionWorker.Stop()
|
||||
}
|
||||
|
||||
// Stop stalemate worker
|
||||
stalemateWorker.Stop()
|
||||
|
||||
// Stop embedding pipeline
|
||||
if embPipeline != nil {
|
||||
embPipeline.Stop()
|
||||
@@ -720,6 +814,28 @@ func generateRandomPassword() string {
|
||||
return hex.EncodeToString(b)
|
||||
}
|
||||
|
||||
// a2aAgentListerAdapter adapts agents.AgentService to a2a.AgentLister.
|
||||
type a2aAgentListerAdapter struct {
|
||||
agentService *agents.AgentService
|
||||
}
|
||||
|
||||
func (a *a2aAgentListerAdapter) ListAllActiveAgents(ctx context.Context) ([]a2a.AgentInfo, error) {
|
||||
agentsList, err := a.agentService.ListAllActiveAgents(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result := make([]a2a.AgentInfo, 0, len(agentsList))
|
||||
for _, agent := range agentsList {
|
||||
result = append(result, a2a.AgentInfo{
|
||||
Name: agent.Name,
|
||||
DisplayName: agent.DisplayName,
|
||||
Type: agent.Type,
|
||||
Capabilities: agent.Capabilities,
|
||||
})
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// agentListerAdapter adapts agents.AgentService to auth.AgentLister.
|
||||
type agentListerAdapter struct {
|
||||
agentService *agents.AgentService
|
||||
@@ -744,6 +860,28 @@ func (a *agentListerAdapter) ListAgentsByOwner(ctx context.Context, ownerID int6
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// idpAgentProvisioner adapts agents.AgentService + channels.Service to idp.AgentProvisioner.
|
||||
type idpAgentProvisioner struct {
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
}
|
||||
|
||||
func (a *idpAgentProvisioner) ProvisionHumanAgent(ctx context.Context, username, displayName string, ownerID int64) error {
|
||||
humanAgent, err := a.agentService.EnsureHumanAgent(ctx, username, displayName, ownerID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("ensure human agent: %w", err)
|
||||
}
|
||||
if humanAgent != nil {
|
||||
if chErr := a.channelService.EnsureMyAgentsChannel(ctx, username, humanAgent.Name); chErr != nil {
|
||||
slog.Warn("failed to ensure my-agents channel after IdP login",
|
||||
"username", username,
|
||||
"error", chErr,
|
||||
)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ensureDefaultMCPClient creates the "mcp-default" public OAuth client if it doesn't exist.
|
||||
// This client is used by MCP clients connecting via OAuth 2.1.
|
||||
func ensureDefaultMCPClient(ctx context.Context, db *sql.DB, bcryptCost int) {
|
||||
@@ -784,3 +922,16 @@ func ensureDefaultMCPClient(ctx context.Context, db *sql.DB, bcryptCost int) {
|
||||
"scopes", "mcp",
|
||||
)
|
||||
}
|
||||
|
||||
// channelLookupAdapter adapts channels.Service to messaging.ChannelLookup.
|
||||
type channelLookupAdapter struct {
|
||||
channelService *channels.Service
|
||||
}
|
||||
|
||||
func (a *channelLookupAdapter) GetChannelIDByName(ctx context.Context, name string) (int64, error) {
|
||||
ch, err := a.channelService.GetChannelByName(ctx, name)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return ch.ID, nil
|
||||
}
|
||||
|
||||
@@ -39,6 +39,10 @@ spec:
|
||||
- name: {{ $key }}
|
||||
value: {{ $value | quote }}
|
||||
{{- end }}
|
||||
{{- with .Values.envFrom }}
|
||||
envFrom:
|
||||
{{- toYaml . | nindent 12 }}
|
||||
{{- end }}
|
||||
livenessProbe:
|
||||
httpGet:
|
||||
path: /healthz
|
||||
@@ -56,6 +60,8 @@ spec:
|
||||
volumeMounts:
|
||||
- name: data
|
||||
mountPath: /data
|
||||
- name: run
|
||||
mountPath: /tmp
|
||||
volumes:
|
||||
- name: data
|
||||
{{- if .Values.persistence.enabled }}
|
||||
@@ -64,6 +70,10 @@ spec:
|
||||
{{- else }}
|
||||
emptyDir: {}
|
||||
{{- end }}
|
||||
- name: run
|
||||
emptyDir:
|
||||
medium: Memory
|
||||
sizeLimit: 1Mi
|
||||
{{- with .Values.nodeSelector }}
|
||||
nodeSelector:
|
||||
{{- toYaml . | nindent 8 }}
|
||||
|
||||
@@ -11,5 +11,8 @@ spec:
|
||||
targetPort: http
|
||||
protocol: TCP
|
||||
name: http
|
||||
{{- if and (eq .Values.service.type "NodePort") .Values.service.nodePort }}
|
||||
nodePort: {{ .Values.service.nodePort }}
|
||||
{{- end }}
|
||||
selector:
|
||||
{{- include "synapbus.selectorLabels" . | nindent 4 }}
|
||||
|
||||
@@ -0,0 +1,320 @@
|
||||
# SynapBus Agent Communication Guide
|
||||
|
||||
How to configure Claude Code and Gemini CLI to proactively communicate via SynapBus.
|
||||
|
||||
## Quick Setup
|
||||
|
||||
### Claude Code
|
||||
|
||||
```bash
|
||||
# Add SynapBus as user-scope MCP server (available in ALL projects)
|
||||
claude mcp add --transport http --scope user \
|
||||
--header "Authorization: Bearer $SYNAPBUS_API_KEY" \
|
||||
synapbus http://kubic.home.arpa:30088/mcp
|
||||
```
|
||||
|
||||
Or project-scope `.mcp.json`:
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"synapbus": {
|
||||
"type": "http",
|
||||
"url": "http://kubic.home.arpa:30088/mcp",
|
||||
"headers": {
|
||||
"Authorization": "Bearer ${SYNAPBUS_API_KEY}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Gemini CLI
|
||||
|
||||
`~/.gemini/settings.json`:
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"synapbus": {
|
||||
"httpUrl": "http://kubic.home.arpa:30088/mcp",
|
||||
"headers": {
|
||||
"Authorization": "Bearer ${SYNAPBUS_API_KEY}"
|
||||
},
|
||||
"timeout": 10000
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
> **Note:** Gemini uses `httpUrl` (not `url`), and tool names are `mcp_synapbus_*` (single underscore) vs Claude's `mcp__synapbus__*` (double underscore).
|
||||
|
||||
---
|
||||
|
||||
## CLAUDE.md Instructions
|
||||
|
||||
Add this block to project `CLAUDE.md` or global `~/.claude/CLAUDE.md`:
|
||||
|
||||
```markdown
|
||||
## SynapBus Communication Protocol
|
||||
|
||||
You have access to SynapBus MCP tools for agent-to-agent messaging.
|
||||
|
||||
### On Session Start (MANDATORY)
|
||||
1. Call `my_status` FIRST before any other work.
|
||||
2. If there are pending DMs with priority >= 7, read and respond before starting planned work.
|
||||
3. Check #bugs-<your-project> for recent reports that may affect your task.
|
||||
4. Search #open-brain for context relevant to your current task.
|
||||
|
||||
### When to Post
|
||||
|
||||
| Event | Channel | Priority |
|
||||
|-------|---------|----------|
|
||||
| Bug found in own project | #bugs-<project> | 7-8 |
|
||||
| Bug found in another project | #bugs-<other-project> | 6-7 |
|
||||
| Bug fixed | Reply to original in #bugs-<project> | 5 |
|
||||
| Task completed (commit/PR) | Project channel or #my-agents-algis | 5 |
|
||||
| Research finding | #news-<topic> | 5 |
|
||||
| Need human approval | #approvals | 8-9 |
|
||||
| Long-term insight | #open-brain | 4 |
|
||||
| Session reflection | #reflections-<agent-name> | 3 |
|
||||
|
||||
### Message Formats
|
||||
|
||||
**Bug Report:**
|
||||
```
|
||||
**BUG: [One-line summary]**
|
||||
[Description]
|
||||
**Expected**: [what should happen]
|
||||
**Actual**: [what happens]
|
||||
**Severity**: High|Medium|Low
|
||||
```
|
||||
|
||||
**Bug Fix:**
|
||||
```
|
||||
**BUG — FIXED**: [summary]
|
||||
**Root cause**: [what was wrong]
|
||||
**Fix**: [what changed]
|
||||
```
|
||||
|
||||
**Task Completion:**
|
||||
```
|
||||
**COMPLETED: [task]**
|
||||
**Changes**: [files/components changed]
|
||||
**Tests**: [pass/fail]
|
||||
**Commit**: [hash]
|
||||
```
|
||||
|
||||
### Rules
|
||||
- Do NOT spam channels with progress updates ("reading file X", "running tests").
|
||||
- Do NOT block waiting for responses. Post and continue working.
|
||||
- Do NOT send API keys, passwords, or secrets in messages.
|
||||
- Do NOT create channels — suggest to human owner instead.
|
||||
- Do NOT post same info to multiple channels. Pick the most specific one.
|
||||
- Default priority is 5. Use 7+ only for genuine blockers or bugs.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## GEMINI.md Instructions
|
||||
|
||||
Add to `~/.gemini/GEMINI.md` or project `.gemini/GEMINI.md`:
|
||||
|
||||
```markdown
|
||||
## SynapBus Communication
|
||||
|
||||
You have SynapBus MCP tools: my_status, send_message, search, execute.
|
||||
|
||||
### Workflow
|
||||
1. On session start, call `my_status` to check inbox.
|
||||
2. Before starting work, search SynapBus for relevant context.
|
||||
3. On task completion, post summary to appropriate channel.
|
||||
4. On bugs found, post structured report to #bugs-<project>.
|
||||
|
||||
### Channels
|
||||
- #open-brain — Shared knowledge base
|
||||
- #bugs-<project> — Bug reports per project
|
||||
- #news-<topic> — Research findings
|
||||
- #approvals — Items needing human approval
|
||||
- #reflections-<agent> — Development reflections
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Skills
|
||||
|
||||
### Claude Code: `/bus` command
|
||||
|
||||
Save as `~/.claude/commands/bus.md` (global) or `.claude/commands/bus.md` (per-project):
|
||||
|
||||
```markdown
|
||||
---
|
||||
description: Check SynapBus inbox, post updates, search context. Usage: /bus [check|post|search|bugs|complete]
|
||||
---
|
||||
|
||||
Parse $ARGUMENTS for subcommand (default: check).
|
||||
|
||||
### check (default)
|
||||
1. Call `my_status` via MCP
|
||||
2. Summarize: pending DMs, unread channels, mentions
|
||||
3. List action items (priority >= 7)
|
||||
|
||||
### search <query>
|
||||
1. Call execute: `call("search_messages", {"query": "<query>", "limit": 10})`
|
||||
2. Present results grouped by channel
|
||||
|
||||
### post <channel> <message>
|
||||
1. Send via `send_message` with channel param
|
||||
|
||||
### bugs [project]
|
||||
1. Read recent messages from #bugs-<project> (infer from repo if not specified)
|
||||
2. Summarize open bugs (no "FIXED" reply)
|
||||
|
||||
### complete
|
||||
1. Gather: git branch, recent commits, changed files
|
||||
2. Format task completion message
|
||||
3. Post to project channel
|
||||
```
|
||||
|
||||
### Claude Code: `/inbox` skill
|
||||
|
||||
Save as `~/.claude/commands/inbox.md`:
|
||||
|
||||
```markdown
|
||||
---
|
||||
description: Check SynapBus inbox for unread messages. Use at session start.
|
||||
---
|
||||
|
||||
1. Call `my_status` to get unread counts
|
||||
2. If pending DMs exist, read them via execute: `call("read_inbox", {})`
|
||||
3. Summarize what needs attention
|
||||
4. If action items exist, ask user how to proceed
|
||||
```
|
||||
|
||||
### Gemini CLI: Skills
|
||||
|
||||
Save as `~/.gemini/skills/synapbus-check/SKILL.md`:
|
||||
|
||||
```yaml
|
||||
---
|
||||
name: synapbus-check
|
||||
description: Check SynapBus inbox and channel updates
|
||||
---
|
||||
Call my_status to check inbox. Summarize pending DMs and unread channels.
|
||||
If action items exist (priority >= 7), list them.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Hooks
|
||||
|
||||
### Claude Code: Auto-check inbox on session start
|
||||
|
||||
`.claude/settings.json`:
|
||||
```json
|
||||
{
|
||||
"hooks": {
|
||||
"SessionStart": [
|
||||
{
|
||||
"hooks": [{
|
||||
"type": "command",
|
||||
"command": "echo '{\"hookSpecificOutput\":{\"additionalContext\":\"IMPORTANT: Call my_status on SynapBus MCP to check your inbox before starting work.\"}}'",
|
||||
"timeout": 2000
|
||||
}]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Gemini CLI: Session start reminder
|
||||
|
||||
`~/.gemini/settings.json` (add to existing):
|
||||
```json
|
||||
{
|
||||
"hooks": {
|
||||
"SessionStart": [{
|
||||
"hooks": [{
|
||||
"type": "command",
|
||||
"command": "echo '{\"hookSpecificOutput\":{\"additionalContext\":\"Call my_status first to check SynapBus messages.\"}}'",
|
||||
"timeout": 2000
|
||||
}]
|
||||
}]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Channel Structure
|
||||
|
||||
### Current
|
||||
| Channel | Purpose |
|
||||
|---------|---------|
|
||||
| #general | Cross-cutting discussion |
|
||||
| #open-brain | Long-term memory (509+ entries) |
|
||||
| #approvals | Human approval queue |
|
||||
| #new_posts | Blog post suggestions |
|
||||
| #bugs-synapbus | SynapBus bug reports |
|
||||
| #news-mcpproxy | MCPProxy research |
|
||||
| #news-synapbus | SynapBus research |
|
||||
| #news-personal-brand | Personal brand research |
|
||||
| #reflections-* | Per-agent development reflections |
|
||||
|
||||
### Recommended Additions
|
||||
| Channel | Purpose |
|
||||
|---------|---------|
|
||||
| #bugs-mcpproxy | MCPProxy bug reports |
|
||||
| #bugs-searcher | Searcher pipeline bugs |
|
||||
| #deployments | All deployment announcements |
|
||||
|
||||
---
|
||||
|
||||
## Cross-Agent Communication Pattern
|
||||
|
||||
```
|
||||
Claude Code (dev agent) Gemini CLI (research agent)
|
||||
| |
|
||||
|-- MCP tools ──> SynapBus <── MCP tools --|
|
||||
| (kubic:30088) |
|
||||
| |
|
||||
├─ my_status (check inbox) ├─ my_status |
|
||||
├─ send_message (post/DM) ├─ send_message|
|
||||
├─ search (find context) ├─ search |
|
||||
└─ execute (advanced actions) └─ execute |
|
||||
```
|
||||
|
||||
Both agents connect with their own API keys. SynapBus identifies each by key.
|
||||
Messages, channels, and search are shared — any agent can read any public channel.
|
||||
|
||||
### Example Workflow
|
||||
1. **Gemini research agent** finds a security vulnerability, posts to `#news-mcpproxy`
|
||||
2. **Claude dev agent** starts session, calls `my_status`, sees unread in `#news-mcpproxy`
|
||||
3. Claude reads the finding, assesses impact, fixes the code
|
||||
4. Claude posts fix confirmation to `#news-mcpproxy` as a reply
|
||||
5. Both agents can search for this exchange later via semantic search
|
||||
|
||||
---
|
||||
|
||||
## Protocol Landscape (March 2026)
|
||||
|
||||
| Protocol | Purpose | Relation to SynapBus |
|
||||
|----------|---------|---------------------|
|
||||
| **MCP** | Agent ↔ Tool connectivity | SynapBus IS an MCP server |
|
||||
| **A2A** (Google) | Agent ↔ Agent task delegation | Complementary — A2A for cross-framework; SynapBus for persistent messaging |
|
||||
| **AG-UI** | Agent ↔ Frontend | SynapBus has its own Web UI |
|
||||
| **AGENTS.md** | Agent capability declaration | Could declare SynapBus agents |
|
||||
|
||||
SynapBus sits at the **messaging infrastructure layer**: persistent channels, semantic search, human-observable audit trail. No other MCP server combines all these properties in a single zero-dependency binary.
|
||||
|
||||
---
|
||||
|
||||
## Anti-Patterns
|
||||
|
||||
| Don't | Why |
|
||||
|-------|-----|
|
||||
| Spam channels with progress updates | Floods channels, wastes embedding costs |
|
||||
| Block waiting for agent responses | Other agent may not run for hours |
|
||||
| Send secrets in messages | Messages are stored, searchable, visible in Web UI |
|
||||
| Post same info to multiple channels | Pick the most specific one |
|
||||
| Create channels autonomously | Suggest to human owner instead |
|
||||
| Act on messages > 7 days old without checking for follow-ups | May be already resolved |
|
||||
| Mark everything priority 8+ | Priority inflation kills triage |
|
||||
@@ -0,0 +1,234 @@
|
||||
# SynapBus Roadmap Research — March 2026
|
||||
|
||||
Synthesized findings from 7 parallel research agents covering protocol integration, deployment patterns, enterprise features, and agent coordination.
|
||||
|
||||
---
|
||||
|
||||
## Executive Summary
|
||||
|
||||
| Topic | Key Finding | Priority |
|
||||
|-------|-------------|----------|
|
||||
| **A2A Protocol** | Agent Cards (1-2 days), then inbound gateway (1-2 weeks). Pure Go SDK. | High |
|
||||
| **AG-UI Protocol** | Complement SSE, not replace. Medium-term value. | Low |
|
||||
| **User-level MCP** | Two agents: `claude-algis` + `gemini-algis`. Claude via MCPProxy, Gemini direct. | Do now |
|
||||
| **Mobile access** | Mobile-responsive Web UI via Cloudflare Tunnel. PWA push later. | Medium |
|
||||
| **Cross-device** | Cloudflare Tunnel works for MCP+SSE. Add Cloudflare Access for security. | Do now |
|
||||
| **Always-online agents** | Keep CronJobs + add K8s Job Handlers for reactive response. No daemons. | Medium |
|
||||
| **GitHub Actions** | Only for CI/CD tasks (PR review). K8s is better for research agents. | Low |
|
||||
| **Enterprise IdP** | `coreos/go-oidc/v3` + `golang.org/x/oauth2`. GitHub/Google/Azure AD. | Medium |
|
||||
| **Task acknowledgment** | Claim-process-done for DMs + ACK/DONE convention for channels + StalemateWorker. | High |
|
||||
|
||||
---
|
||||
|
||||
## 1. A2A Protocol Integration
|
||||
|
||||
**What**: Google's Agent-to-Agent protocol (v1.0, 22.6k stars, Linux Foundation).
|
||||
|
||||
**Why**: Makes SynapBus agents discoverable and callable by external frameworks (Google ADK, Microsoft Agent Framework, Strands, LangGraph).
|
||||
|
||||
**Phased approach**:
|
||||
- **Phase 1** (1-2 days): Expose `/.well-known/agent-card.json` from agent registry
|
||||
- **Phase 2** (1-2 weeks): Inbound A2A gateway — external agents send tasks → SynapBus routes as DMs
|
||||
- **Phase 3** (future): Outbound A2A client — SynapBus agents call external A2A agents
|
||||
|
||||
**Key mappings**: A2A Task → SynapBus Conversation, A2A Message → SynapBus Message, A2A Agent Card → SynapBus Agent record.
|
||||
|
||||
**Go SDK**: `github.com/a2aproject/a2a-go` — pure Go, compatible with zero-CGO constraint.
|
||||
|
||||
**vs MCP Tasks (SEP-1686)**: Complementary. MCP Tasks = long-running operations within existing MCP connection. A2A = cross-framework agent interop with discovery.
|
||||
|
||||
---
|
||||
|
||||
## 2. AG-UI Protocol
|
||||
|
||||
**What**: CopilotKit's Agent-User Interaction protocol (12.5k stars). Standardizes agent → frontend streaming.
|
||||
|
||||
**Assessment**: Medium-term value, not urgent. SynapBus's current SSE (notifications) and AG-UI (agent activity streaming) solve different problems.
|
||||
|
||||
**If pursued**: Expose `/ag-ui/run` endpoint that wraps channel activity as AG-UI events. Would let external React frontends (CopilotKit) connect to SynapBus agents.
|
||||
|
||||
**Recommendation**: Watch and plan, but don't build yet. Current SSE + Web UI covers all current use cases.
|
||||
|
||||
---
|
||||
|
||||
## 3. User-Level MCP + Agent Identity
|
||||
|
||||
**Recommendation: Two agent accounts** — `claude-algis` and `gemini-algis`.
|
||||
|
||||
| Tool | SynapBus Access | Agent Identity |
|
||||
|------|----------------|----------------|
|
||||
| Claude Code | Via MCPProxy (user-level, auto-auth) | `claude-algis` |
|
||||
| Gemini CLI | Direct connection (user-level) | `gemini-algis` |
|
||||
| Searcher agents | Direct per-agent keys (unchanged) | `research-*` |
|
||||
|
||||
**Why not one per project**: 20+ projects = 20+ dead agent accounts. **Why not one shared**: Can't tell Claude vs Gemini apart.
|
||||
|
||||
**MCPProxy gateway**: MCPProxy at `localhost:8080` already proxies to kubic. Add `Authorization: Bearer <claude-algis-key>` to the synapbus upstream config in `~/.mcpproxy/mcp_config.json`. All Claude Code projects get SynapBus via BM25 discovery.
|
||||
|
||||
**Gemini**: Direct connection in `~/.gemini/settings.json` with own key.
|
||||
|
||||
**Setup steps**:
|
||||
1. Create agents: `kubectl exec -n synapbus deploy/synapbus -- /synapbus agent create --name claude-algis --display-name "Claude (Algis)" --owner 1`
|
||||
2. Add Bearer header to MCPProxy synapbus upstream
|
||||
3. Remove project-level SynapBus configs from Claude Code
|
||||
4. Add direct SynapBus entry to Gemini settings
|
||||
|
||||
---
|
||||
|
||||
## 4. Mobile Access + Cross-Device
|
||||
|
||||
### Mobile (fastest path)
|
||||
Make Web UI mobile-responsive (sidebar → drawer, touch-friendly compose). Access via `hub.synapbus.dev` on phone. Existing SSE + auth work through Cloudflare Tunnel.
|
||||
|
||||
**Later**: PWA manifest + Web Push for background notifications. iOS supports Web Push since 16.4.
|
||||
|
||||
**Approval on mobile**: Add approve/reject buttons in Web UI for `#approvals` messages (detect `type: "approval_request"` in metadata).
|
||||
|
||||
### Cross-device (home + work)
|
||||
- Home kubic: agents connect locally (`localhost:30088`)
|
||||
- Work laptop: Claude/Gemini connect via `hub.synapbus.dev` tunnel
|
||||
- Benefits: shared context, research feeds dev work, bugs flow between environments
|
||||
|
||||
**Security**: Add Cloudflare Access policy on `hub.synapbus.dev` (email OTP or GitHub SSO). Service tokens for headless agents. OAuth 2.1 remains primary auth layer.
|
||||
|
||||
**Tunnel compatibility**: MCP Streamable HTTP + SSE both work through Cloudflare Tunnel. 30s heartbeats keep connections alive. ~20-50ms round-trip latency.
|
||||
|
||||
---
|
||||
|
||||
## 5. Always-Online Agents
|
||||
|
||||
### Recommended: Hybrid CronJob + K8s Job Handler
|
||||
|
||||
| Workload | Mechanism | Latency | Cost |
|
||||
|----------|-----------|---------|------|
|
||||
| Periodic research sweeps | K8s CronJob (existing) | 4-6h | Low |
|
||||
| Respond to messages/mentions | SynapBus K8s Job Handler | ~10s | Per-event |
|
||||
| Code review/CI tasks | GitHub Actions | ~1m | Free tier |
|
||||
| Always-on daemon | NOT RECOMMENDED | — | High |
|
||||
|
||||
**Keep CronJobs** for scheduled research (already working, staggered schedules).
|
||||
|
||||
**Add K8s Job Handlers** for real-time response: register handlers per agent for `message.received` and `message.mentioned` events. SynapBus spawns K8s Jobs with message context as env vars.
|
||||
|
||||
**Don't use long-running Deployments**: Context windows fill up, resources wasted on single-node MicroK8s.
|
||||
|
||||
**Don't use KEDA**: SynapBus's built-in K8s Job Runner already handles event-driven dispatch.
|
||||
|
||||
### Notable open-source projects
|
||||
- **Kelos**: K8s-native agent orchestration via CRDs (Tasks, AgentConfigs, TaskSpawners)
|
||||
- **Hortator**: Agent reincarnation pattern — checkpoint to `/memory/`, respawn with fresh context
|
||||
- **claude-code-action**: Official GitHub Action for Claude Code in CI/CD
|
||||
|
||||
---
|
||||
|
||||
## 6. Enterprise Identity Providers
|
||||
|
||||
### Architecture
|
||||
```
|
||||
External IdP (GitHub / Google / Azure AD)
|
||||
↓ OIDC Authorization Code Flow
|
||||
SynapBus Identity Layer (NEW: internal/auth/idp/)
|
||||
↓ Creates/links local User + session
|
||||
Existing Auth (Web UI sessions, OAuth AS for MCP, API keys)
|
||||
```
|
||||
|
||||
### Libraries
|
||||
- `coreos/go-oidc/v3` — OIDC discovery + ID token verification (Google, Azure AD)
|
||||
- `golang.org/x/oauth2` — OAuth flow (all providers, already indirect dep)
|
||||
- GitHub: manual OAuth + API calls (not OIDC-compliant)
|
||||
|
||||
### Database
|
||||
```sql
|
||||
CREATE TABLE user_identities (
|
||||
user_id INTEGER REFERENCES users(id),
|
||||
provider TEXT NOT NULL, -- 'github', 'google', 'azuread'
|
||||
external_id TEXT NOT NULL, -- stable provider user ID
|
||||
email TEXT,
|
||||
UNIQUE(provider, external_id)
|
||||
);
|
||||
|
||||
CREATE TABLE identity_providers (
|
||||
id TEXT PRIMARY KEY, -- 'github', 'google', 'azuread-gcore'
|
||||
type TEXT NOT NULL, -- 'github', 'oidc'
|
||||
client_id TEXT NOT NULL,
|
||||
client_secret_encrypted TEXT,
|
||||
issuer_url TEXT, -- OIDC discovery (NULL for GitHub)
|
||||
allowed_domains TEXT, -- '["gcore.com"]'
|
||||
group_mapping TEXT, -- '{"SynapBus-Admins":"admin"}'
|
||||
tenant_id TEXT, -- Azure AD
|
||||
enabled INTEGER DEFAULT 1
|
||||
);
|
||||
```
|
||||
|
||||
### Provider-specific notes
|
||||
- **GitHub**: `read:user` + `user:email` scopes. Map `github_user.id` → external_id.
|
||||
- **Google**: Full OIDC. Restrict to Workspace domain via `hd` claim. Validate server-side.
|
||||
- **Azure AD (Gcore)**: Tenant-specific OIDC. Group claims for role mapping. App Registration in Entra admin center. Handle >200 groups overage.
|
||||
|
||||
### Routes
|
||||
```
|
||||
GET /auth/providers → list enabled IdPs (for login page buttons)
|
||||
GET /auth/login/{provider} → redirect to IdP
|
||||
GET /auth/callback/{provider} → handle callback, create/link user, set session
|
||||
```
|
||||
|
||||
### Multi-tenant: One instance per org (matches local-first philosophy).
|
||||
|
||||
---
|
||||
|
||||
## 7. Task Acknowledgment & Enforcement
|
||||
|
||||
### DM Lifecycle (already built)
|
||||
`pending` → `processing` (claim) → `done` / `failed`
|
||||
|
||||
### CLAUDE.md Instructions (add to all projects)
|
||||
```markdown
|
||||
## Message Acknowledgment (MANDATORY)
|
||||
1. Call `claim_messages` to lock DMs to you
|
||||
2. Process each message
|
||||
3. `mark_done` (success) or `mark_done` with status "failed" + reason
|
||||
4. Never leave claimed messages orphaned — mark failed before session ends
|
||||
```
|
||||
|
||||
### Channel Convention (no code changes)
|
||||
- `ACK: <summary>` — I see it, working on it
|
||||
- `DONE: <summary>` — completed
|
||||
- `BLOCKED: <reason>` — cannot proceed
|
||||
- `DELEGATED: @<agent>` — passed to another agent
|
||||
|
||||
### Enforcement: StalemateWorker (new, small PR)
|
||||
Background worker (like ExpiryWorker/RetentionWorker):
|
||||
- `processing` messages > 24h → auto-fail with "claim timeout"
|
||||
- `pending` messages > 4h → send reminder DM (priority 7)
|
||||
- `pending` messages > 48h → escalate to `#approvals` (priority 9)
|
||||
|
||||
### Channel `reply_to` gap
|
||||
`send_channel_message` action lacks `reply_to` parameter. Add it to enable threaded acknowledgments in channels.
|
||||
|
||||
---
|
||||
|
||||
## Implementation Priority
|
||||
|
||||
### Do Now (zero code)
|
||||
1. Create `claude-algis` + `gemini-algis` agents
|
||||
2. Configure MCPProxy upstream with auth header
|
||||
3. Add acknowledgment protocol to CLAUDE.md / GEMINI.md
|
||||
4. Add SessionStart hooks for inbox checking
|
||||
|
||||
### Next Sprint
|
||||
5. StalemateWorker for message timeout/escalation
|
||||
6. Add `reply_to` to `send_channel_message` action
|
||||
7. A2A Agent Cards (`/.well-known/agent-card.json`)
|
||||
8. Mobile-responsive Web UI (sidebar drawer)
|
||||
|
||||
### Next Month
|
||||
9. A2A inbound gateway (external agents → SynapBus)
|
||||
10. K8s Job Handlers for reactive agent activation
|
||||
11. Enterprise IdP (GitHub + Google + Azure AD)
|
||||
12. PWA with Web Push notifications
|
||||
|
||||
### Future
|
||||
13. A2A outbound client (SynapBus agents → external agents)
|
||||
14. AG-UI endpoint for external frontends
|
||||
15. Telegram bot for mobile approvals
|
||||
16. Approval buttons in Web UI
|
||||
@@ -3,7 +3,11 @@ module github.com/synapbus/synapbus
|
||||
go 1.25.0
|
||||
|
||||
require (
|
||||
github.com/SherClockHolmes/webpush-go v1.4.0
|
||||
github.com/TFMV/hnsw v0.4.0
|
||||
github.com/coreos/go-oidc/v3 v3.17.0
|
||||
github.com/dop251/goja v0.0.0-20260311135729-065cd970411c
|
||||
github.com/evanw/esbuild v0.27.4
|
||||
github.com/go-chi/chi/v5 v5.2.5
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/mark3labs/mcp-go v0.45.0
|
||||
@@ -12,6 +16,7 @@ require (
|
||||
github.com/prometheus/client_model v0.6.2
|
||||
github.com/spf13/cobra v1.10.2
|
||||
golang.org/x/crypto v0.49.0
|
||||
golang.org/x/oauth2 v0.36.0
|
||||
golang.org/x/time v0.9.0
|
||||
k8s.io/api v0.35.2
|
||||
k8s.io/apimachinery v0.35.2
|
||||
@@ -30,21 +35,26 @@ require (
|
||||
github.com/cristalhq/jwt/v4 v4.0.2 // indirect
|
||||
github.com/davecgh/go-spew v1.1.1 // indirect
|
||||
github.com/dgraph-io/ristretto v1.0.0 // indirect
|
||||
github.com/dlclark/regexp2 v1.11.4 // indirect
|
||||
github.com/dustin/go-humanize v1.0.1 // indirect
|
||||
github.com/emicklei/go-restful/v3 v3.12.2 // indirect
|
||||
github.com/felixge/httpsnoop v1.0.4 // indirect
|
||||
github.com/fsnotify/fsnotify v1.6.0 // indirect
|
||||
github.com/fxamacker/cbor/v2 v2.9.0 // indirect
|
||||
github.com/go-jose/go-jose/v3 v3.0.3 // indirect
|
||||
github.com/go-jose/go-jose/v4 v4.1.3 // indirect
|
||||
github.com/go-logr/logr v1.4.3 // indirect
|
||||
github.com/go-logr/stdr v1.2.2 // indirect
|
||||
github.com/go-openapi/jsonpointer v0.21.0 // indirect
|
||||
github.com/go-openapi/jsonreference v0.20.2 // indirect
|
||||
github.com/go-openapi/swag v0.23.0 // indirect
|
||||
github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
|
||||
github.com/gobuffalo/pop/v6 v6.1.1 // indirect
|
||||
github.com/gogo/protobuf v1.3.2 // indirect
|
||||
github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
|
||||
github.com/golang/mock v1.6.0 // indirect
|
||||
github.com/google/gnostic-models v0.7.0 // indirect
|
||||
github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 // indirect
|
||||
github.com/google/renameio v1.0.1 // indirect
|
||||
github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 // indirect
|
||||
@@ -108,7 +118,6 @@ require (
|
||||
golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
|
||||
golang.org/x/mod v0.33.0 // indirect
|
||||
golang.org/x/net v0.51.0 // indirect
|
||||
golang.org/x/oauth2 v0.30.0 // indirect
|
||||
golang.org/x/sync v0.20.0 // indirect
|
||||
golang.org/x/sys v0.42.0 // indirect
|
||||
golang.org/x/term v0.41.0 // indirect
|
||||
|
||||
@@ -41,6 +41,8 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym
|
||||
github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
|
||||
github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
|
||||
github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
|
||||
github.com/SherClockHolmes/webpush-go v1.4.0 h1:ocnzNKWN23T9nvHi6IfyrQjkIc0oJWv1B1pULsf9i3s=
|
||||
github.com/SherClockHolmes/webpush-go v1.4.0/go.mod h1:XSq8pKX11vNV8MJEMwjrlTkxhAj1zKfxmyhdV7Pd6UA=
|
||||
github.com/TFMV/hnsw v0.4.0 h1:k61xD3V9LzzwUMDLaHCn+1PbvMbJj33KRdUPiUtuj7k=
|
||||
github.com/TFMV/hnsw v0.4.0/go.mod h1:YPCKBOTpl3KzZxYBTVbR+uH7US5HpprYkDLALt/bgTY=
|
||||
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
|
||||
@@ -67,6 +69,8 @@ github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGX
|
||||
github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
|
||||
github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
|
||||
github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
|
||||
github.com/coreos/go-oidc/v3 v3.17.0 h1:hWBGaQfbi0iVviX4ibC7bk8OKT5qNr4klBaCHVNvehc=
|
||||
github.com/coreos/go-oidc/v3 v3.17.0/go.mod h1:wqPbKFrVnE90vty060SB40FCJ8fTHTxSwyXJqZH+sI8=
|
||||
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
|
||||
github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
|
||||
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
|
||||
@@ -82,6 +86,10 @@ github.com/dgraph-io/ristretto v1.0.0 h1:SYG07bONKMlFDUYu5pEu3DGAh8c2OFNzKm6G9J4
|
||||
github.com/dgraph-io/ristretto v1.0.0/go.mod h1:jTi2FiYEhQ1NsMmA7DeBykizjOuY88NhKBkepyu1jPc=
|
||||
github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
|
||||
github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
|
||||
github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
|
||||
github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
|
||||
github.com/dop251/goja v0.0.0-20260311135729-065cd970411c h1:OcLmPfx1T1RmZVHHFwWMPaZDdRf0DBMZOFMVWJa7Pdk=
|
||||
github.com/dop251/goja v0.0.0-20260311135729-065cd970411c/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
|
||||
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
|
||||
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
|
||||
github.com/emicklei/go-restful/v3 v3.12.2 h1:DhwDP0vY3k8ZzE0RunuJy8GhNpPL6zqLkDf9B/a0/xU=
|
||||
@@ -92,6 +100,8 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
|
||||
github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
|
||||
github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
|
||||
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
|
||||
github.com/evanw/esbuild v0.27.4 h1:8opEixKkH9EDsdjxC/aPmpk1KPwQOcyknDo5m5xIFxI=
|
||||
github.com/evanw/esbuild v0.27.4/go.mod h1:D2vIQZqV/vIf/VRHtViaUtViZmG7o+kKmlBfVQuRi48=
|
||||
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
|
||||
github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
|
||||
github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
|
||||
@@ -111,6 +121,8 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2
|
||||
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
|
||||
github.com/go-jose/go-jose/v3 v3.0.3 h1:fFKWeig/irsp7XD2zBxvnmA/XaRWp5V3CBsZXJF7G7k=
|
||||
github.com/go-jose/go-jose/v3 v3.0.3/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ=
|
||||
github.com/go-jose/go-jose/v4 v4.1.3 h1:CVLmWDhDVRa6Mi/IgCgaopNosCaHz7zrMeF9MlZRkrs=
|
||||
github.com/go-jose/go-jose/v4 v4.1.3/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
|
||||
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
|
||||
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
|
||||
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
|
||||
@@ -126,6 +138,8 @@ github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En
|
||||
github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
|
||||
github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
|
||||
github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
|
||||
github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
|
||||
github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
|
||||
github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
|
||||
github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
|
||||
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
|
||||
@@ -154,6 +168,8 @@ github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRx
|
||||
github.com/gofrs/uuid v4.3.1+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
|
||||
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
|
||||
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
|
||||
github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
|
||||
github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
|
||||
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
|
||||
github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
|
||||
github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
|
||||
@@ -197,6 +213,7 @@ github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
|
||||
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
|
||||
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
|
||||
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
|
||||
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
|
||||
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
|
||||
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
|
||||
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
|
||||
@@ -561,7 +578,10 @@ golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5y
|
||||
golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
|
||||
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
|
||||
golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
|
||||
golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
|
||||
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
|
||||
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
|
||||
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
|
||||
golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
|
||||
golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
|
||||
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
|
||||
@@ -603,6 +623,9 @@ golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
||||
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
|
||||
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
|
||||
golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
|
||||
golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
|
||||
golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
|
||||
golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
|
||||
golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
|
||||
golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
|
||||
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||
@@ -645,6 +668,9 @@ golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfS
|
||||
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
|
||||
golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
|
||||
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
|
||||
golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
|
||||
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
|
||||
golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
|
||||
golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo=
|
||||
golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y=
|
||||
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
@@ -656,8 +682,8 @@ golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ
|
||||
golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
|
||||
golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
|
||||
golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
|
||||
golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
|
||||
golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
|
||||
golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
|
||||
golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
|
||||
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
@@ -672,6 +698,10 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJ
|
||||
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
|
||||
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
|
||||
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
||||
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
@@ -728,9 +758,13 @@ golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
|
||||
golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||
golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
|
||||
golang.org/x/telemetry v0.0.0-20260209163413-e7419c687ee4 h1:bTLqdHv7xrGlFbvf5/TXNxy/iUwwdkjhqQTJDjW7aj0=
|
||||
golang.org/x/telemetry v0.0.0-20260209163413-e7419c687ee4/go.mod h1:g5NllXBEermZrmR51cJDQxmJUHUOfRAaNyWBM+R+548=
|
||||
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
|
||||
@@ -740,7 +774,10 @@ golang.org/x/term v0.0.0-20220722155259-a9ba230a4035/go.mod h1:jbD1KX2456YbFQfuX
|
||||
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
|
||||
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
|
||||
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
|
||||
golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
|
||||
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
|
||||
golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
|
||||
golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
|
||||
golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
|
||||
golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
|
||||
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
@@ -753,7 +790,10 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
|
||||
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
|
||||
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
|
||||
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
|
||||
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
|
||||
golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
|
||||
golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
|
||||
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
@@ -819,6 +859,8 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
|
||||
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
|
||||
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
|
||||
golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4=
|
||||
golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
|
||||
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
|
||||
golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
|
||||
golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
|
||||
golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
@@ -938,6 +980,7 @@ gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
|
||||
gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
|
||||
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
|
||||
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
// Package a2a provides A2A Agent Card discovery for SynapBus.
|
||||
// The Agent Card is a JSON document that describes the hub and its registered
|
||||
// agents, following the A2A Agent Card specification.
|
||||
package a2a
|
||||
|
||||
import "encoding/json"
|
||||
|
||||
// AgentCard is the A2A Agent Card document returned by the discovery endpoint.
|
||||
type AgentCard struct {
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
Version string `json:"version"`
|
||||
SupportedInterfaces []AgentInterface `json:"supported_interfaces"`
|
||||
Capabilities AgentCapabilities `json:"capabilities"`
|
||||
Skills []AgentSkill `json:"skills"`
|
||||
SecuritySchemes map[string]any `json:"security_schemes"`
|
||||
DefaultInputModes []string `json:"default_input_modes"`
|
||||
DefaultOutputModes []string `json:"default_output_modes"`
|
||||
}
|
||||
|
||||
// AgentInterface describes a protocol endpoint the hub supports.
|
||||
type AgentInterface struct {
|
||||
URL string `json:"url"`
|
||||
ProtocolBinding string `json:"protocol_binding"`
|
||||
}
|
||||
|
||||
// AgentCapabilities declares hub-level capabilities.
|
||||
type AgentCapabilities struct {
|
||||
Streaming bool `json:"streaming"`
|
||||
PushNotifications bool `json:"push_notifications"`
|
||||
}
|
||||
|
||||
// AgentSkill represents a single agent registered on the hub, mapped as an
|
||||
// A2A skill.
|
||||
type AgentSkill struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description,omitempty"`
|
||||
Tags []string `json:"tags,omitempty"`
|
||||
}
|
||||
|
||||
// AgentInfo is a lightweight struct used to pass agent data from the registry
|
||||
// into the card generator without leaking internal types.
|
||||
type AgentInfo struct {
|
||||
Name string
|
||||
DisplayName string
|
||||
Type string
|
||||
Capabilities json.RawMessage
|
||||
}
|
||||
|
||||
// GenerateAgentCard builds an AgentCard from the hub configuration and a list
|
||||
// of registered agents.
|
||||
func GenerateAgentCard(baseURL string, version string, agents []AgentInfo) *AgentCard {
|
||||
skills := make([]AgentSkill, 0, len(agents))
|
||||
for _, a := range agents {
|
||||
skill := AgentSkill{
|
||||
ID: a.Name,
|
||||
Name: a.DisplayName,
|
||||
}
|
||||
if skill.Name == "" {
|
||||
skill.Name = a.Name
|
||||
}
|
||||
|
||||
// Parse capabilities JSON for description and tags.
|
||||
if len(a.Capabilities) > 0 {
|
||||
var caps map[string]interface{}
|
||||
if json.Unmarshal(a.Capabilities, &caps) == nil {
|
||||
if desc, ok := caps["description"].(string); ok {
|
||||
skill.Description = desc
|
||||
}
|
||||
if role, ok := caps["role"].(string); ok {
|
||||
skill.Tags = append(skill.Tags, role)
|
||||
}
|
||||
if tagsRaw, ok := caps["tags"]; ok {
|
||||
switch v := tagsRaw.(type) {
|
||||
case []interface{}:
|
||||
for _, t := range v {
|
||||
if s, ok := t.(string); ok {
|
||||
skill.Tags = append(skill.Tags, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add agent type as a tag.
|
||||
if a.Type != "" {
|
||||
skill.Tags = append(skill.Tags, a.Type)
|
||||
}
|
||||
|
||||
skills = append(skills, skill)
|
||||
}
|
||||
|
||||
return &AgentCard{
|
||||
Name: "SynapBus Hub",
|
||||
Description: "MCP-native agent-to-agent messaging hub",
|
||||
Version: version,
|
||||
SupportedInterfaces: []AgentInterface{
|
||||
{
|
||||
URL: baseURL + "/a2a",
|
||||
ProtocolBinding: "JSONRPC",
|
||||
},
|
||||
},
|
||||
Capabilities: AgentCapabilities{
|
||||
Streaming: true,
|
||||
PushNotifications: false,
|
||||
},
|
||||
Skills: skills,
|
||||
SecuritySchemes: map[string]any{
|
||||
"apiKey": map[string]any{
|
||||
"type": "apiKey",
|
||||
"in": "header",
|
||||
"name": "Authorization",
|
||||
"scheme": "Bearer",
|
||||
},
|
||||
"oauth2": map[string]any{
|
||||
"type": "oauth2",
|
||||
"flows": map[string]any{
|
||||
"authorizationCode": map[string]any{
|
||||
"authorizationUrl": baseURL + "/oauth/authorize",
|
||||
"tokenUrl": baseURL + "/oauth/token",
|
||||
"scopes": map[string]string{
|
||||
"mcp": "MCP protocol access",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
DefaultInputModes: []string{"text"},
|
||||
DefaultOutputModes: []string{"text"},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
package a2a
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGenerateAgentCard_WithAgents(t *testing.T) {
|
||||
agents := []AgentInfo{
|
||||
{Name: "research-bot", DisplayName: "Research Bot", Type: "ai", Capabilities: json.RawMessage(`{"role":"researcher","description":"Searches the web"}`)},
|
||||
{Name: "social-commenter", DisplayName: "Social Commenter", Type: "ai", Capabilities: json.RawMessage(`{"tags":["social","marketing"]}`)},
|
||||
{Name: "data-analyst", DisplayName: "", Type: "ai", Capabilities: json.RawMessage(`{}`)},
|
||||
}
|
||||
|
||||
card := GenerateAgentCard("http://localhost:8080", "1.0.0", agents)
|
||||
|
||||
if card.Name != "SynapBus Hub" {
|
||||
t.Errorf("name = %q, want %q", card.Name, "SynapBus Hub")
|
||||
}
|
||||
if card.Version != "1.0.0" {
|
||||
t.Errorf("version = %q, want %q", card.Version, "1.0.0")
|
||||
}
|
||||
if len(card.Skills) != 3 {
|
||||
t.Fatalf("skills count = %d, want 3", len(card.Skills))
|
||||
}
|
||||
|
||||
// Verify first skill has description and tags from capabilities
|
||||
s0 := card.Skills[0]
|
||||
if s0.ID != "research-bot" {
|
||||
t.Errorf("skill[0].id = %q, want %q", s0.ID, "research-bot")
|
||||
}
|
||||
if s0.Name != "Research Bot" {
|
||||
t.Errorf("skill[0].name = %q, want %q", s0.Name, "Research Bot")
|
||||
}
|
||||
if s0.Description != "Searches the web" {
|
||||
t.Errorf("skill[0].description = %q, want %q", s0.Description, "Searches the web")
|
||||
}
|
||||
// Should have "researcher" from role + "ai" from type
|
||||
if len(s0.Tags) < 2 {
|
||||
t.Errorf("skill[0].tags = %v, expected at least 2 tags", s0.Tags)
|
||||
}
|
||||
|
||||
// Second skill should have tags from capabilities "tags" field
|
||||
s1 := card.Skills[1]
|
||||
if s1.ID != "social-commenter" {
|
||||
t.Errorf("skill[1].id = %q, want %q", s1.ID, "social-commenter")
|
||||
}
|
||||
foundSocial := false
|
||||
for _, tag := range s1.Tags {
|
||||
if tag == "social" {
|
||||
foundSocial = true
|
||||
}
|
||||
}
|
||||
if !foundSocial {
|
||||
t.Errorf("skill[1].tags = %v, expected 'social' tag", s1.Tags)
|
||||
}
|
||||
|
||||
// Third skill should use name as display name (since DisplayName is empty)
|
||||
s2 := card.Skills[2]
|
||||
if s2.Name != "data-analyst" {
|
||||
t.Errorf("skill[2].name = %q, want %q (fallback to Name)", s2.Name, "data-analyst")
|
||||
}
|
||||
|
||||
// Verify JSON serialization round-trips cleanly
|
||||
data, err := json.Marshal(card)
|
||||
if err != nil {
|
||||
t.Fatalf("marshal card: %v", err)
|
||||
}
|
||||
var decoded AgentCard
|
||||
if err := json.Unmarshal(data, &decoded); err != nil {
|
||||
t.Fatalf("unmarshal card: %v", err)
|
||||
}
|
||||
if decoded.Name != card.Name {
|
||||
t.Errorf("round-trip name mismatch")
|
||||
}
|
||||
if len(decoded.Skills) != 3 {
|
||||
t.Errorf("round-trip skills count = %d, want 3", len(decoded.Skills))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGenerateAgentCard_WithCapabilities_TagsPopulated(t *testing.T) {
|
||||
agents := []AgentInfo{
|
||||
{
|
||||
Name: "smart-agent",
|
||||
DisplayName: "Smart Agent",
|
||||
Type: "ai",
|
||||
Capabilities: json.RawMessage(`{"role":"analyst","description":"Analyzes data","tags":["ml","data"]}`),
|
||||
},
|
||||
}
|
||||
|
||||
card := GenerateAgentCard("http://example.com", "2.0.0", agents)
|
||||
|
||||
if len(card.Skills) != 1 {
|
||||
t.Fatalf("skills count = %d, want 1", len(card.Skills))
|
||||
}
|
||||
|
||||
skill := card.Skills[0]
|
||||
if skill.Description != "Analyzes data" {
|
||||
t.Errorf("description = %q, want %q", skill.Description, "Analyzes data")
|
||||
}
|
||||
|
||||
// Expect tags: "analyst" (from role), "ml", "data" (from tags), "ai" (from type)
|
||||
expectedTags := map[string]bool{"analyst": false, "ml": false, "data": false, "ai": false}
|
||||
for _, tag := range skill.Tags {
|
||||
if _, ok := expectedTags[tag]; ok {
|
||||
expectedTags[tag] = true
|
||||
}
|
||||
}
|
||||
for tag, found := range expectedTags {
|
||||
if !found {
|
||||
t.Errorf("missing expected tag %q in %v", tag, skill.Tags)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGenerateAgentCard_NoAgents(t *testing.T) {
|
||||
card := GenerateAgentCard("http://localhost:8080", "0.1.0", nil)
|
||||
|
||||
if card.Name != "SynapBus Hub" {
|
||||
t.Errorf("name = %q, want %q", card.Name, "SynapBus Hub")
|
||||
}
|
||||
if len(card.Skills) != 0 {
|
||||
t.Errorf("skills count = %d, want 0", len(card.Skills))
|
||||
}
|
||||
if len(card.SupportedInterfaces) != 1 {
|
||||
t.Fatalf("interfaces count = %d, want 1", len(card.SupportedInterfaces))
|
||||
}
|
||||
if card.SupportedInterfaces[0].URL != "http://localhost:8080/a2a" {
|
||||
t.Errorf("interface url = %q, want %q", card.SupportedInterfaces[0].URL, "http://localhost:8080/a2a")
|
||||
}
|
||||
if card.SecuritySchemes == nil {
|
||||
t.Error("security_schemes should not be nil")
|
||||
}
|
||||
}
|
||||
|
||||
// mockAgentLister implements AgentLister for handler tests.
|
||||
type mockAgentLister struct {
|
||||
agents []AgentInfo
|
||||
err error
|
||||
}
|
||||
|
||||
func (m *mockAgentLister) ListAllActiveAgents(_ context.Context) ([]AgentInfo, error) {
|
||||
return m.agents, m.err
|
||||
}
|
||||
|
||||
func TestHandler_Returns200WithCorrectContentType(t *testing.T) {
|
||||
lister := &mockAgentLister{
|
||||
agents: []AgentInfo{
|
||||
{Name: "bot-1", DisplayName: "Bot One", Type: "ai"},
|
||||
{Name: "bot-2", DisplayName: "Bot Two", Type: "ai"},
|
||||
},
|
||||
}
|
||||
|
||||
handler := NewAgentCardHandler(lister, "http://localhost:8080", "1.0.0")
|
||||
req := httptest.NewRequest(http.MethodGet, "/.well-known/agent-card.json", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
|
||||
handler.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
ct := rr.Header().Get("Content-Type")
|
||||
if ct != "application/json" {
|
||||
t.Errorf("Content-Type = %q, want %q", ct, "application/json")
|
||||
}
|
||||
|
||||
var card AgentCard
|
||||
if err := json.NewDecoder(rr.Body).Decode(&card); err != nil {
|
||||
t.Fatalf("decode response: %v", err)
|
||||
}
|
||||
if card.Name != "SynapBus Hub" {
|
||||
t.Errorf("card.name = %q, want %q", card.Name, "SynapBus Hub")
|
||||
}
|
||||
if len(card.Skills) != 2 {
|
||||
t.Errorf("card.skills count = %d, want 2", len(card.Skills))
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandler_DerivesBaseURLFromRequest(t *testing.T) {
|
||||
lister := &mockAgentLister{agents: nil}
|
||||
|
||||
// Empty configuredBaseURL — should derive from request
|
||||
handler := NewAgentCardHandler(lister, "", "1.0.0")
|
||||
req := httptest.NewRequest(http.MethodGet, "/.well-known/agent-card.json", nil)
|
||||
req.Host = "myhost:9090"
|
||||
rr := httptest.NewRecorder()
|
||||
|
||||
handler.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var card AgentCard
|
||||
if err := json.NewDecoder(rr.Body).Decode(&card); err != nil {
|
||||
t.Fatalf("decode: %v", err)
|
||||
}
|
||||
if card.SupportedInterfaces[0].URL != "http://myhost:9090/a2a" {
|
||||
t.Errorf("interface url = %q, want %q", card.SupportedInterfaces[0].URL, "http://myhost:9090/a2a")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandler_RejectsNonGET(t *testing.T) {
|
||||
lister := &mockAgentLister{agents: nil}
|
||||
handler := NewAgentCardHandler(lister, "http://localhost:8080", "1.0.0")
|
||||
req := httptest.NewRequest(http.MethodPost, "/.well-known/agent-card.json", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
|
||||
handler.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusMethodNotAllowed {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusMethodNotAllowed)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,306 @@
|
||||
package a2a
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
)
|
||||
|
||||
// MessagingService defines the messaging operations needed by the A2A gateway.
|
||||
type MessagingService interface {
|
||||
SendMessage(ctx context.Context, from, to, body string, opts messaging.SendOptions) (*messaging.Message, error)
|
||||
GetConversation(ctx context.Context, id int64) (*messaging.Conversation, []*messaging.Message, error)
|
||||
}
|
||||
|
||||
// AgentService defines the agent operations needed by the A2A gateway.
|
||||
type AgentService interface {
|
||||
GetAgent(ctx context.Context, name string) (*agents.Agent, error)
|
||||
}
|
||||
|
||||
// Gateway handles inbound A2A JSON-RPC requests.
|
||||
type Gateway struct {
|
||||
taskStore *A2ATaskStore
|
||||
msgService MessagingService
|
||||
agentService AgentService
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewGateway creates a new A2A gateway.
|
||||
func NewGateway(taskStore *A2ATaskStore, msgService MessagingService, agentService AgentService) *Gateway {
|
||||
return &Gateway{
|
||||
taskStore: taskStore,
|
||||
msgService: msgService,
|
||||
agentService: agentService,
|
||||
logger: slog.Default().With("component", "a2a-gateway"),
|
||||
}
|
||||
}
|
||||
|
||||
// JSON-RPC 2.0 request/response types.
|
||||
|
||||
type jsonRPCRequest struct {
|
||||
JSONRPC string `json:"jsonrpc"`
|
||||
ID json.RawMessage `json:"id"`
|
||||
Method string `json:"method"`
|
||||
Params json.RawMessage `json:"params,omitempty"`
|
||||
}
|
||||
|
||||
type jsonRPCResponse struct {
|
||||
JSONRPC string `json:"jsonrpc"`
|
||||
ID json.RawMessage `json:"id"`
|
||||
Result any `json:"result,omitempty"`
|
||||
Error *jsonRPCError `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type jsonRPCError struct {
|
||||
Code int `json:"code"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
// Standard JSON-RPC 2.0 error codes.
|
||||
const (
|
||||
errCodeParse = -32700
|
||||
errCodeInvalidReq = -32600
|
||||
errCodeNoMethod = -32601
|
||||
errCodeInvalidParams = -32602
|
||||
errCodeInternal = -32603
|
||||
)
|
||||
|
||||
// HandleJSONRPC dispatches incoming JSON-RPC 2.0 requests to the appropriate handler.
|
||||
func (g *Gateway) HandleJSONRPC(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost {
|
||||
http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) // 1 MiB limit
|
||||
if err != nil {
|
||||
writeJSONRPC(w, nil, nil, &jsonRPCError{Code: errCodeParse, Message: "failed to read request body"})
|
||||
return
|
||||
}
|
||||
|
||||
var req jsonRPCRequest
|
||||
if err := json.Unmarshal(body, &req); err != nil {
|
||||
writeJSONRPC(w, nil, nil, &jsonRPCError{Code: errCodeParse, Message: "invalid JSON"})
|
||||
return
|
||||
}
|
||||
|
||||
if req.JSONRPC != "2.0" {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidReq, Message: "jsonrpc must be \"2.0\""})
|
||||
return
|
||||
}
|
||||
|
||||
// Extract the calling agent from auth context.
|
||||
callerAgent, ok := agents.AgentFromContext(r.Context())
|
||||
callerName := ""
|
||||
if ok && callerAgent != nil {
|
||||
callerName = callerAgent.Name
|
||||
}
|
||||
|
||||
switch req.Method {
|
||||
case "message.send":
|
||||
g.handleMessageSend(w, r.Context(), req, callerName)
|
||||
case "tasks.get":
|
||||
g.handleTasksGet(w, r.Context(), req)
|
||||
case "tasks.cancel":
|
||||
g.handleTasksCancel(w, r.Context(), req)
|
||||
default:
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeNoMethod, Message: fmt.Sprintf("unknown method: %s", req.Method)})
|
||||
}
|
||||
}
|
||||
|
||||
// message.send params
|
||||
|
||||
type messageSendParams struct {
|
||||
Message struct {
|
||||
Body string `json:"body"`
|
||||
Metadata struct {
|
||||
TargetAgent string `json:"target_agent"`
|
||||
} `json:"metadata"`
|
||||
} `json:"message"`
|
||||
}
|
||||
|
||||
func (g *Gateway) handleMessageSend(w http.ResponseWriter, ctx context.Context, req jsonRPCRequest, callerName string) {
|
||||
var params messageSendParams
|
||||
if err := json.Unmarshal(req.Params, ¶ms); err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "invalid params: " + err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
targetAgent := params.Message.Metadata.TargetAgent
|
||||
if targetAgent == "" {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "params.message.metadata.target_agent is required"})
|
||||
return
|
||||
}
|
||||
|
||||
messageBody := params.Message.Body
|
||||
if messageBody == "" {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "params.message.body is required"})
|
||||
return
|
||||
}
|
||||
|
||||
// Validate target agent exists.
|
||||
_, err := g.agentService.GetAgent(ctx, targetAgent)
|
||||
if err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: fmt.Sprintf("target agent not found: %s", targetAgent)})
|
||||
return
|
||||
}
|
||||
|
||||
// Create task.
|
||||
taskID := uuid.New().String()
|
||||
contextID := uuid.New().String()
|
||||
|
||||
// Determine the sender name for the DM. Use the caller's identity if
|
||||
// authenticated, otherwise fall back to "a2a-gateway" so SendMessage
|
||||
// has a non-empty from field.
|
||||
senderName := callerName
|
||||
if senderName == "" {
|
||||
senderName = "a2a-gateway"
|
||||
}
|
||||
|
||||
// Build metadata containing the a2a_task_id.
|
||||
metaJSON, _ := json.Marshal(map[string]string{"a2a_task_id": taskID})
|
||||
|
||||
// Send DM to target agent.
|
||||
msg, err := g.msgService.SendMessage(ctx, senderName, targetAgent, messageBody, messaging.SendOptions{
|
||||
Subject: fmt.Sprintf("A2A Task %s", taskID),
|
||||
Metadata: string(metaJSON),
|
||||
})
|
||||
if err != nil {
|
||||
g.logger.Error("failed to send DM for A2A task", "task_id", taskID, "error", err)
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInternal, Message: "failed to deliver message: " + err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
convID := msg.ConversationID
|
||||
task := &A2ATask{
|
||||
ID: taskID,
|
||||
ContextID: contextID,
|
||||
TargetAgent: targetAgent,
|
||||
SourceAgent: callerName,
|
||||
ConversationID: &convID,
|
||||
State: StateSubmitted,
|
||||
}
|
||||
|
||||
if err := g.taskStore.CreateTask(ctx, task); err != nil {
|
||||
g.logger.Error("failed to create A2A task", "task_id", taskID, "error", err)
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInternal, Message: "failed to create task"})
|
||||
return
|
||||
}
|
||||
|
||||
g.logger.Info("A2A task created",
|
||||
"task_id", taskID,
|
||||
"target_agent", targetAgent,
|
||||
"source_agent", callerName,
|
||||
"message_id", msg.ID,
|
||||
)
|
||||
|
||||
writeJSONRPC(w, req.ID, task, nil)
|
||||
}
|
||||
|
||||
// tasks.get params
|
||||
|
||||
type tasksGetParams struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
|
||||
func (g *Gateway) handleTasksGet(w http.ResponseWriter, ctx context.Context, req jsonRPCRequest) {
|
||||
var params tasksGetParams
|
||||
if err := json.Unmarshal(req.Params, ¶ms); err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "invalid params: " + err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
if params.ID == "" {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "params.id is required"})
|
||||
return
|
||||
}
|
||||
|
||||
task, err := g.taskStore.GetTask(ctx, params.ID)
|
||||
if err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
// If the task has a conversation and is still SUBMITTED, check whether the
|
||||
// target agent has replied, which indicates completion.
|
||||
if task.State == StateSubmitted && task.ConversationID != nil {
|
||||
_, msgs, err := g.msgService.GetConversation(ctx, *task.ConversationID)
|
||||
if err == nil && len(msgs) > 1 {
|
||||
// Check if the target agent sent a reply (any message from target after the first).
|
||||
for _, m := range msgs[1:] {
|
||||
if m.FromAgent == task.TargetAgent {
|
||||
task.State = StateCompleted
|
||||
_ = g.taskStore.UpdateTaskState(ctx, task.ID, StateCompleted)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
writeJSONRPC(w, req.ID, task, nil)
|
||||
}
|
||||
|
||||
// tasks.cancel params
|
||||
|
||||
type tasksCancelParams struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
|
||||
func (g *Gateway) handleTasksCancel(w http.ResponseWriter, ctx context.Context, req jsonRPCRequest) {
|
||||
var params tasksCancelParams
|
||||
if err := json.Unmarshal(req.Params, ¶ms); err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "invalid params: " + err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
if params.ID == "" {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: "params.id is required"})
|
||||
return
|
||||
}
|
||||
|
||||
task, err := g.taskStore.GetTask(ctx, params.ID)
|
||||
if err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
// Cannot cancel a terminal task.
|
||||
if task.State == StateCompleted || task.State == StateCanceled {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInvalidParams, Message: fmt.Sprintf("task is already in terminal state: %s", task.State)})
|
||||
return
|
||||
}
|
||||
|
||||
if err := g.taskStore.UpdateTaskState(ctx, task.ID, StateCanceled); err != nil {
|
||||
writeJSONRPC(w, req.ID, nil, &jsonRPCError{Code: errCodeInternal, Message: "failed to cancel task"})
|
||||
return
|
||||
}
|
||||
|
||||
task.State = StateCanceled
|
||||
g.logger.Info("A2A task canceled", "task_id", task.ID)
|
||||
|
||||
writeJSONRPC(w, req.ID, task, nil)
|
||||
}
|
||||
|
||||
// writeJSONRPC writes a JSON-RPC 2.0 response.
|
||||
func writeJSONRPC(w http.ResponseWriter, id json.RawMessage, result any, rpcErr *jsonRPCError) {
|
||||
resp := jsonRPCResponse{
|
||||
JSONRPC: "2.0",
|
||||
ID: id,
|
||||
Result: result,
|
||||
Error: rpcErr,
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if rpcErr != nil {
|
||||
// Use 200 for JSON-RPC errors (per spec), but set result to nil.
|
||||
resp.Result = nil
|
||||
}
|
||||
json.NewEncoder(w).Encode(resp)
|
||||
}
|
||||
@@ -0,0 +1,483 @@
|
||||
package a2a
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
)
|
||||
|
||||
// --- test helpers ---
|
||||
|
||||
func newTestDB(t *testing.T) *sql.DB {
|
||||
t.Helper()
|
||||
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", t.Name())
|
||||
db, err := sql.Open("sqlite", dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("open database: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { db.Close() })
|
||||
|
||||
if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
|
||||
t.Fatalf("enable foreign keys: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
if err := storage.RunMigrations(ctx, db); err != nil {
|
||||
t.Fatalf("run migrations: %v", err)
|
||||
}
|
||||
|
||||
// Seed a test user for owner_id FK
|
||||
db.Exec(`INSERT OR IGNORE INTO users (id, username, password_hash, display_name) VALUES (1, 'testowner', 'hash', 'Test Owner')`)
|
||||
|
||||
return db
|
||||
}
|
||||
|
||||
func seedAgent(t *testing.T, db *sql.DB, name string) {
|
||||
t.Helper()
|
||||
_, err := db.Exec(
|
||||
`INSERT OR IGNORE INTO agents (name, display_name, type, capabilities, owner_id, api_key_hash, status) VALUES (?, ?, 'ai', '{}', 1, 'testhash', 'active')`,
|
||||
name, name,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("seed agent %s: %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
// mockMsgService implements MessagingService for testing.
|
||||
type mockMsgService struct {
|
||||
lastFrom string
|
||||
lastTo string
|
||||
lastBody string
|
||||
lastOpts messaging.SendOptions
|
||||
sendErr error
|
||||
returnMsg *messaging.Message
|
||||
convMsgs []*messaging.Message
|
||||
getConvErr error
|
||||
}
|
||||
|
||||
func (m *mockMsgService) SendMessage(_ context.Context, from, to, body string, opts messaging.SendOptions) (*messaging.Message, error) {
|
||||
m.lastFrom = from
|
||||
m.lastTo = to
|
||||
m.lastBody = body
|
||||
m.lastOpts = opts
|
||||
if m.sendErr != nil {
|
||||
return nil, m.sendErr
|
||||
}
|
||||
if m.returnMsg != nil {
|
||||
return m.returnMsg, nil
|
||||
}
|
||||
return &messaging.Message{
|
||||
ID: 1,
|
||||
ConversationID: 100,
|
||||
FromAgent: from,
|
||||
ToAgent: to,
|
||||
Body: body,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *mockMsgService) GetConversation(_ context.Context, id int64) (*messaging.Conversation, []*messaging.Message, error) {
|
||||
if m.getConvErr != nil {
|
||||
return nil, nil, m.getConvErr
|
||||
}
|
||||
conv := &messaging.Conversation{ID: id}
|
||||
return conv, m.convMsgs, nil
|
||||
}
|
||||
|
||||
// mockAgentService implements AgentService for testing.
|
||||
type mockAgentService struct {
|
||||
agents map[string]*agents.Agent
|
||||
}
|
||||
|
||||
func (m *mockAgentService) GetAgent(_ context.Context, name string) (*agents.Agent, error) {
|
||||
if a, ok := m.agents[name]; ok {
|
||||
return a, nil
|
||||
}
|
||||
return nil, fmt.Errorf("agent not found: %s", name)
|
||||
}
|
||||
|
||||
func newTestGateway(t *testing.T) (*Gateway, *mockMsgService, *mockAgentService, *A2ATaskStore) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
seedAgent(t, db, "target-bot")
|
||||
seedAgent(t, db, "sender-bot")
|
||||
|
||||
taskStore := NewA2ATaskStore(db)
|
||||
msgSvc := &mockMsgService{}
|
||||
agentSvc := &mockAgentService{
|
||||
agents: map[string]*agents.Agent{
|
||||
"target-bot": {ID: 1, Name: "target-bot", Status: "active"},
|
||||
"sender-bot": {ID: 2, Name: "sender-bot", Status: "active"},
|
||||
},
|
||||
}
|
||||
|
||||
gw := NewGateway(taskStore, msgSvc, agentSvc)
|
||||
return gw, msgSvc, agentSvc, taskStore
|
||||
}
|
||||
|
||||
func jsonRPCCall(method string, params any) []byte {
|
||||
p, _ := json.Marshal(params)
|
||||
req := map[string]any{
|
||||
"jsonrpc": "2.0",
|
||||
"id": 1,
|
||||
"method": method,
|
||||
"params": json.RawMessage(p),
|
||||
}
|
||||
b, _ := json.Marshal(req)
|
||||
return b
|
||||
}
|
||||
|
||||
func doRequest(t *testing.T, gw *Gateway, body []byte, agentCtx *agents.Agent) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
req := httptest.NewRequest(http.MethodPost, "/a2a", bytes.NewReader(body))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
if agentCtx != nil {
|
||||
req = req.WithContext(agents.ContextWithAgent(req.Context(), agentCtx))
|
||||
}
|
||||
w := httptest.NewRecorder()
|
||||
gw.HandleJSONRPC(w, req)
|
||||
return w
|
||||
}
|
||||
|
||||
func parseResponse(t *testing.T, w *httptest.ResponseRecorder) jsonRPCResponse {
|
||||
t.Helper()
|
||||
var resp jsonRPCResponse
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatalf("unmarshal response: %v\nbody: %s", err, w.Body.String())
|
||||
}
|
||||
return resp
|
||||
}
|
||||
|
||||
// --- tests ---
|
||||
|
||||
func TestMessageSend_CreatesTaskAndDM(t *testing.T) {
|
||||
gw, msgSvc, _, taskStore := newTestGateway(t)
|
||||
|
||||
body := jsonRPCCall("message.send", map[string]any{
|
||||
"message": map[string]any{
|
||||
"body": "Hello target bot",
|
||||
"metadata": map[string]string{
|
||||
"target_agent": "target-bot",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
callerAgent := &agents.Agent{Name: "sender-bot"}
|
||||
w := doRequest(t, gw, body, callerAgent)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error != nil {
|
||||
t.Fatalf("unexpected error: code=%d message=%s", resp.Error.Code, resp.Error.Message)
|
||||
}
|
||||
|
||||
// Verify a task was returned.
|
||||
resultBytes, _ := json.Marshal(resp.Result)
|
||||
var task A2ATask
|
||||
if err := json.Unmarshal(resultBytes, &task); err != nil {
|
||||
t.Fatalf("unmarshal task result: %v", err)
|
||||
}
|
||||
|
||||
if task.ID == "" {
|
||||
t.Error("task ID should not be empty")
|
||||
}
|
||||
if task.State != StateSubmitted {
|
||||
t.Errorf("task state = %q, want %q", task.State, StateSubmitted)
|
||||
}
|
||||
if task.TargetAgent != "target-bot" {
|
||||
t.Errorf("target_agent = %q, want %q", task.TargetAgent, "target-bot")
|
||||
}
|
||||
if task.SourceAgent != "sender-bot" {
|
||||
t.Errorf("source_agent = %q, want %q", task.SourceAgent, "sender-bot")
|
||||
}
|
||||
|
||||
// Verify the DM was sent.
|
||||
if msgSvc.lastTo != "target-bot" {
|
||||
t.Errorf("DM to = %q, want %q", msgSvc.lastTo, "target-bot")
|
||||
}
|
||||
if msgSvc.lastFrom != "sender-bot" {
|
||||
t.Errorf("DM from = %q, want %q", msgSvc.lastFrom, "sender-bot")
|
||||
}
|
||||
if msgSvc.lastBody != "Hello target bot" {
|
||||
t.Errorf("DM body = %q, want %q", msgSvc.lastBody, "Hello target bot")
|
||||
}
|
||||
|
||||
// Verify metadata contains a2a_task_id.
|
||||
var meta map[string]string
|
||||
if err := json.Unmarshal([]byte(msgSvc.lastOpts.Metadata), &meta); err != nil {
|
||||
t.Fatalf("unmarshal metadata: %v", err)
|
||||
}
|
||||
if meta["a2a_task_id"] != task.ID {
|
||||
t.Errorf("metadata a2a_task_id = %q, want %q", meta["a2a_task_id"], task.ID)
|
||||
}
|
||||
|
||||
// Verify task is persisted.
|
||||
stored, err := taskStore.GetTask(context.Background(), task.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("GetTask: %v", err)
|
||||
}
|
||||
if stored.State != StateSubmitted {
|
||||
t.Errorf("stored task state = %q, want %q", stored.State, StateSubmitted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTasksGet_ReturnsTask(t *testing.T) {
|
||||
gw, _, _, taskStore := newTestGateway(t)
|
||||
|
||||
// Create a task directly.
|
||||
convID := int64(100)
|
||||
task := &A2ATask{
|
||||
ID: "test-task-123",
|
||||
ContextID: "ctx-123",
|
||||
TargetAgent: "target-bot",
|
||||
SourceAgent: "sender-bot",
|
||||
ConversationID: &convID,
|
||||
State: StateSubmitted,
|
||||
}
|
||||
if err := taskStore.CreateTask(context.Background(), task); err != nil {
|
||||
t.Fatalf("CreateTask: %v", err)
|
||||
}
|
||||
|
||||
body := jsonRPCCall("tasks.get", map[string]string{"id": "test-task-123"})
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error != nil {
|
||||
t.Fatalf("unexpected error: code=%d message=%s", resp.Error.Code, resp.Error.Message)
|
||||
}
|
||||
|
||||
resultBytes, _ := json.Marshal(resp.Result)
|
||||
var got A2ATask
|
||||
if err := json.Unmarshal(resultBytes, &got); err != nil {
|
||||
t.Fatalf("unmarshal task result: %v", err)
|
||||
}
|
||||
|
||||
if got.ID != "test-task-123" {
|
||||
t.Errorf("task ID = %q, want %q", got.ID, "test-task-123")
|
||||
}
|
||||
if got.State != StateSubmitted {
|
||||
t.Errorf("task state = %q, want %q", got.State, StateSubmitted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTasksGet_CompletesOnReply(t *testing.T) {
|
||||
gw, msgSvc, _, taskStore := newTestGateway(t)
|
||||
|
||||
// Create a task.
|
||||
convID := int64(100)
|
||||
task := &A2ATask{
|
||||
ID: "task-reply-test",
|
||||
ContextID: "ctx-456",
|
||||
TargetAgent: "target-bot",
|
||||
SourceAgent: "sender-bot",
|
||||
ConversationID: &convID,
|
||||
State: StateSubmitted,
|
||||
}
|
||||
if err := taskStore.CreateTask(context.Background(), task); err != nil {
|
||||
t.Fatalf("CreateTask: %v", err)
|
||||
}
|
||||
|
||||
// Simulate the target agent having replied.
|
||||
msgSvc.convMsgs = []*messaging.Message{
|
||||
{ID: 1, FromAgent: "sender-bot", Body: "Hello"},
|
||||
{ID: 2, FromAgent: "target-bot", Body: "Reply from target"},
|
||||
}
|
||||
|
||||
body := jsonRPCCall("tasks.get", map[string]string{"id": "task-reply-test"})
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error != nil {
|
||||
t.Fatalf("unexpected error: code=%d message=%s", resp.Error.Code, resp.Error.Message)
|
||||
}
|
||||
|
||||
resultBytes, _ := json.Marshal(resp.Result)
|
||||
var got A2ATask
|
||||
if err := json.Unmarshal(resultBytes, &got); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
if got.State != StateCompleted {
|
||||
t.Errorf("task state = %q, want %q (target agent replied)", got.State, StateCompleted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTasksCancel_TransitionsToCanceled(t *testing.T) {
|
||||
gw, _, _, taskStore := newTestGateway(t)
|
||||
|
||||
task := &A2ATask{
|
||||
ID: "task-cancel-test",
|
||||
ContextID: "ctx-789",
|
||||
TargetAgent: "target-bot",
|
||||
SourceAgent: "sender-bot",
|
||||
State: StateSubmitted,
|
||||
}
|
||||
if err := taskStore.CreateTask(context.Background(), task); err != nil {
|
||||
t.Fatalf("CreateTask: %v", err)
|
||||
}
|
||||
|
||||
body := jsonRPCCall("tasks.cancel", map[string]string{"id": "task-cancel-test"})
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error != nil {
|
||||
t.Fatalf("unexpected error: code=%d message=%s", resp.Error.Code, resp.Error.Message)
|
||||
}
|
||||
|
||||
resultBytes, _ := json.Marshal(resp.Result)
|
||||
var got A2ATask
|
||||
if err := json.Unmarshal(resultBytes, &got); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
if got.State != StateCanceled {
|
||||
t.Errorf("task state = %q, want %q", got.State, StateCanceled)
|
||||
}
|
||||
|
||||
// Verify persisted state.
|
||||
stored, err := taskStore.GetTask(context.Background(), "task-cancel-test")
|
||||
if err != nil {
|
||||
t.Fatalf("GetTask: %v", err)
|
||||
}
|
||||
if stored.State != StateCanceled {
|
||||
t.Errorf("stored state = %q, want %q", stored.State, StateCanceled)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTasksCancel_TerminalStateError(t *testing.T) {
|
||||
gw, _, _, taskStore := newTestGateway(t)
|
||||
|
||||
task := &A2ATask{
|
||||
ID: "task-already-done",
|
||||
ContextID: "ctx-done",
|
||||
TargetAgent: "target-bot",
|
||||
State: StateCompleted,
|
||||
}
|
||||
if err := taskStore.CreateTask(context.Background(), task); err != nil {
|
||||
t.Fatalf("CreateTask: %v", err)
|
||||
}
|
||||
|
||||
body := jsonRPCCall("tasks.cancel", map[string]string{"id": "task-already-done"})
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error == nil {
|
||||
t.Fatal("expected error for canceling terminal task")
|
||||
}
|
||||
if resp.Error.Code != errCodeInvalidParams {
|
||||
t.Errorf("error code = %d, want %d", resp.Error.Code, errCodeInvalidParams)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageSend_NonExistentAgent(t *testing.T) {
|
||||
gw, _, _, _ := newTestGateway(t)
|
||||
|
||||
body := jsonRPCCall("message.send", map[string]any{
|
||||
"message": map[string]any{
|
||||
"body": "Hello ghost",
|
||||
"metadata": map[string]string{
|
||||
"target_agent": "does-not-exist",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error == nil {
|
||||
t.Fatal("expected error for non-existent target agent")
|
||||
}
|
||||
if resp.Error.Code != errCodeInvalidParams {
|
||||
t.Errorf("error code = %d, want %d", resp.Error.Code, errCodeInvalidParams)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInvalidJSONRPC(t *testing.T) {
|
||||
gw, _, _, _ := newTestGateway(t)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
body string
|
||||
}{
|
||||
{
|
||||
name: "not JSON",
|
||||
body: "this is not json",
|
||||
},
|
||||
{
|
||||
name: "wrong jsonrpc version",
|
||||
body: `{"jsonrpc":"1.0","id":1,"method":"message.send","params":{}}`,
|
||||
},
|
||||
{
|
||||
name: "unknown method",
|
||||
body: `{"jsonrpc":"2.0","id":1,"method":"unknown.method","params":{}}`,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
req := httptest.NewRequest(http.MethodPost, "/a2a", bytes.NewBufferString(tt.body))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
w := httptest.NewRecorder()
|
||||
gw.HandleJSONRPC(w, req)
|
||||
|
||||
var resp jsonRPCResponse
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatalf("unmarshal response: %v\nbody: %s", err, w.Body.String())
|
||||
}
|
||||
if resp.Error == nil {
|
||||
t.Error("expected error response")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnauthenticatedRequest_NoAgentContext(t *testing.T) {
|
||||
// This tests that message.send works even without an authenticated agent
|
||||
// in context (caller is anonymous), using "a2a-gateway" as the sender.
|
||||
gw, msgSvc, _, _ := newTestGateway(t)
|
||||
|
||||
body := jsonRPCCall("message.send", map[string]any{
|
||||
"message": map[string]any{
|
||||
"body": "Hello from anonymous",
|
||||
"metadata": map[string]string{
|
||||
"target_agent": "target-bot",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
// No agent context — simulates unauthenticated-at-gateway-level
|
||||
// (in practice, the auth middleware would block this; this tests the
|
||||
// gateway's fallback behavior).
|
||||
w := doRequest(t, gw, body, nil)
|
||||
resp := parseResponse(t, w)
|
||||
|
||||
if resp.Error != nil {
|
||||
t.Fatalf("unexpected error: code=%d message=%s", resp.Error.Code, resp.Error.Message)
|
||||
}
|
||||
|
||||
// Should use "a2a-gateway" as sender when no caller agent.
|
||||
if msgSvc.lastFrom != "a2a-gateway" {
|
||||
t.Errorf("DM from = %q, want %q", msgSvc.lastFrom, "a2a-gateway")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHTTPMethodNotAllowed(t *testing.T) {
|
||||
gw, _, _, _ := newTestGateway(t)
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/a2a", nil)
|
||||
w := httptest.NewRecorder()
|
||||
gw.HandleJSONRPC(w, req)
|
||||
|
||||
if w.Code != http.StatusMethodNotAllowed {
|
||||
t.Errorf("status = %d, want %d", w.Code, http.StatusMethodNotAllowed)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package a2a
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// AgentLister abstracts the operation of listing active non-human agents.
|
||||
type AgentLister interface {
|
||||
ListAllActiveAgents(ctx context.Context) ([]AgentInfo, error)
|
||||
}
|
||||
|
||||
// NewAgentCardHandler returns an http.HandlerFunc that serves the A2A Agent
|
||||
// Card JSON document at /.well-known/agent-card.json.
|
||||
//
|
||||
// The handler is public (no auth required) because Agent Cards are meant for
|
||||
// discovery. If configuredBaseURL is empty the base URL is derived from the
|
||||
// incoming request (respecting X-Forwarded-* headers).
|
||||
func NewAgentCardHandler(agentLister AgentLister, configuredBaseURL string, version string) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodGet {
|
||||
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
// Derive base URL from request if not configured.
|
||||
baseURL := configuredBaseURL
|
||||
if baseURL == "" {
|
||||
scheme := "http"
|
||||
if r.TLS != nil {
|
||||
scheme = "https"
|
||||
}
|
||||
if proto := r.Header.Get("X-Forwarded-Proto"); proto != "" {
|
||||
scheme = proto
|
||||
}
|
||||
host := r.Host
|
||||
if fwdHost := r.Header.Get("X-Forwarded-Host"); fwdHost != "" {
|
||||
host = fwdHost
|
||||
}
|
||||
baseURL = scheme + "://" + host
|
||||
}
|
||||
|
||||
agents, err := agentLister.ListAllActiveAgents(r.Context())
|
||||
if err != nil {
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
card := GenerateAgentCard(baseURL, version, agents)
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Header().Set("Cache-Control", "public, max-age=60")
|
||||
json.NewEncoder(w).Encode(card)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
// Package a2a provides the A2A (Agent-to-Agent) inbound gateway for SynapBus.
|
||||
// External A2A-compliant agents can send tasks to SynapBus agents via JSON-RPC.
|
||||
package a2a
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Task states following the A2A protocol.
|
||||
const (
|
||||
StateSubmitted = "SUBMITTED"
|
||||
StateCompleted = "COMPLETED"
|
||||
StateCanceled = "CANCELED"
|
||||
)
|
||||
|
||||
// A2ATask represents an inbound A2A task tracked by the gateway.
|
||||
type A2ATask struct {
|
||||
ID string `json:"id"`
|
||||
ContextID string `json:"context_id"`
|
||||
TargetAgent string `json:"target_agent"`
|
||||
SourceAgent string `json:"source_agent"`
|
||||
ConversationID *int64 `json:"conversation_id,omitempty"`
|
||||
State string `json:"state"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
// A2ATaskStore provides CRUD operations for A2A tasks backed by SQLite.
|
||||
type A2ATaskStore struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
// NewA2ATaskStore creates a new task store.
|
||||
func NewA2ATaskStore(db *sql.DB) *A2ATaskStore {
|
||||
return &A2ATaskStore{db: db}
|
||||
}
|
||||
|
||||
// CreateTask inserts a new A2A task into the database.
|
||||
func (s *A2ATaskStore) CreateTask(ctx context.Context, task *A2ATask) error {
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`INSERT INTO a2a_tasks (id, context_id, target_agent, source_agent, conversation_id, state, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`,
|
||||
task.ID, task.ContextID, task.TargetAgent, task.SourceAgent, task.ConversationID, task.State,
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("insert a2a task: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetTask returns an A2A task by its ID.
|
||||
func (s *A2ATaskStore) GetTask(ctx context.Context, id string) (*A2ATask, error) {
|
||||
var task A2ATask
|
||||
var conversationID sql.NullInt64
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT id, context_id, target_agent, source_agent, conversation_id, state, created_at, updated_at
|
||||
FROM a2a_tasks WHERE id = ?`, id,
|
||||
).Scan(&task.ID, &task.ContextID, &task.TargetAgent, &task.SourceAgent,
|
||||
&conversationID, &task.State, &task.CreatedAt, &task.UpdatedAt)
|
||||
if err != nil {
|
||||
if err == sql.ErrNoRows {
|
||||
return nil, fmt.Errorf("a2a task not found: %s", id)
|
||||
}
|
||||
return nil, fmt.Errorf("get a2a task: %w", err)
|
||||
}
|
||||
if conversationID.Valid {
|
||||
task.ConversationID = &conversationID.Int64
|
||||
}
|
||||
return &task, nil
|
||||
}
|
||||
|
||||
// UpdateTaskState transitions a task to a new state.
|
||||
func (s *A2ATaskStore) UpdateTaskState(ctx context.Context, id, state string) error {
|
||||
result, err := s.db.ExecContext(ctx,
|
||||
`UPDATE a2a_tasks SET state = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
|
||||
state, id,
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("update a2a task state: %w", err)
|
||||
}
|
||||
rows, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("get rows affected: %w", err)
|
||||
}
|
||||
if rows == 0 {
|
||||
return fmt.Errorf("a2a task not found: %s", id)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ListTasks returns tasks for a target agent, optionally filtered by state.
|
||||
func (s *A2ATaskStore) ListTasks(ctx context.Context, targetAgent, state string) ([]*A2ATask, error) {
|
||||
var query string
|
||||
var args []any
|
||||
|
||||
if state != "" {
|
||||
query = `SELECT id, context_id, target_agent, source_agent, conversation_id, state, created_at, updated_at
|
||||
FROM a2a_tasks WHERE target_agent = ? AND state = ? ORDER BY created_at DESC`
|
||||
args = []any{targetAgent, state}
|
||||
} else {
|
||||
query = `SELECT id, context_id, target_agent, source_agent, conversation_id, state, created_at, updated_at
|
||||
FROM a2a_tasks WHERE target_agent = ? ORDER BY created_at DESC`
|
||||
args = []any{targetAgent}
|
||||
}
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, query, args...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list a2a tasks: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var tasks []*A2ATask
|
||||
for rows.Next() {
|
||||
var task A2ATask
|
||||
var conversationID sql.NullInt64
|
||||
if err := rows.Scan(&task.ID, &task.ContextID, &task.TargetAgent, &task.SourceAgent,
|
||||
&conversationID, &task.State, &task.CreatedAt, &task.UpdatedAt); err != nil {
|
||||
return nil, fmt.Errorf("scan a2a task: %w", err)
|
||||
}
|
||||
if conversationID.Valid {
|
||||
task.ConversationID = &conversationID.Int64
|
||||
}
|
||||
tasks = append(tasks, &task)
|
||||
}
|
||||
if tasks == nil {
|
||||
tasks = []*A2ATask{}
|
||||
}
|
||||
return tasks, rows.Err()
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package actions
|
||||
|
||||
import (
|
||||
"math"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// SearchResult pairs an action with a relevance score.
|
||||
type SearchResult struct {
|
||||
Action Action `json:"action"`
|
||||
Score float64 `json:"score"`
|
||||
}
|
||||
|
||||
// Index provides BM25 search over the action catalog.
|
||||
type Index struct {
|
||||
actions []Action
|
||||
// Pre-computed document tokens (name + category + description + param names).
|
||||
docs [][]string
|
||||
// IDF values per term across all documents.
|
||||
idf map[string]float64
|
||||
// Average document length.
|
||||
avgDL float64
|
||||
}
|
||||
|
||||
// NewIndex builds a BM25 index from the provided actions.
|
||||
func NewIndex(actions []Action) *Index {
|
||||
idx := &Index{
|
||||
actions: actions,
|
||||
docs: make([][]string, len(actions)),
|
||||
idf: make(map[string]float64),
|
||||
}
|
||||
|
||||
// Tokenize each action into a bag of words.
|
||||
df := make(map[string]int) // document frequency per term
|
||||
totalLen := 0
|
||||
for i, a := range actions {
|
||||
tokens := tokenize(a)
|
||||
idx.docs[i] = tokens
|
||||
totalLen += len(tokens)
|
||||
// Count unique terms in this document.
|
||||
seen := make(map[string]bool)
|
||||
for _, t := range tokens {
|
||||
if !seen[t] {
|
||||
df[t]++
|
||||
seen[t] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
n := float64(len(actions))
|
||||
if n > 0 {
|
||||
idx.avgDL = float64(totalLen) / n
|
||||
}
|
||||
|
||||
// Compute IDF for each term.
|
||||
for term, freq := range df {
|
||||
idx.idf[term] = math.Log(1 + (n-float64(freq)+0.5)/(float64(freq)+0.5))
|
||||
}
|
||||
|
||||
return idx
|
||||
}
|
||||
|
||||
// Search returns actions matching the query, sorted by relevance score.
|
||||
// If query is empty, returns all actions with score 0 (browse mode).
|
||||
func (idx *Index) Search(query string, limit int) []SearchResult {
|
||||
if limit <= 0 {
|
||||
limit = 5
|
||||
}
|
||||
if limit > 20 {
|
||||
limit = 20
|
||||
}
|
||||
|
||||
// Browse mode: return all actions.
|
||||
if strings.TrimSpace(query) == "" {
|
||||
results := make([]SearchResult, len(idx.actions))
|
||||
for i, a := range idx.actions {
|
||||
results[i] = SearchResult{Action: a, Score: 0}
|
||||
}
|
||||
if len(results) > limit {
|
||||
results = results[:limit]
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
queryTerms := strings.Fields(strings.ToLower(query))
|
||||
|
||||
// BM25 parameters.
|
||||
const k1 = 1.2
|
||||
const b = 0.75
|
||||
|
||||
type scored struct {
|
||||
idx int
|
||||
score float64
|
||||
}
|
||||
|
||||
var scored_docs []scored
|
||||
for i, docTokens := range idx.docs {
|
||||
score := 0.0
|
||||
dl := float64(len(docTokens))
|
||||
tf := termFrequency(docTokens)
|
||||
|
||||
for _, qt := range queryTerms {
|
||||
idfVal := idx.idf[qt]
|
||||
freq := float64(tf[qt])
|
||||
if freq == 0 {
|
||||
continue
|
||||
}
|
||||
numerator := freq * (k1 + 1)
|
||||
denominator := freq + k1*(1-b+b*dl/idx.avgDL)
|
||||
score += idfVal * numerator / denominator
|
||||
}
|
||||
|
||||
if score > 0 {
|
||||
scored_docs = append(scored_docs, scored{idx: i, score: score})
|
||||
}
|
||||
}
|
||||
|
||||
sort.Slice(scored_docs, func(i, j int) bool {
|
||||
return scored_docs[i].score > scored_docs[j].score
|
||||
})
|
||||
|
||||
if len(scored_docs) > limit {
|
||||
scored_docs = scored_docs[:limit]
|
||||
}
|
||||
|
||||
results := make([]SearchResult, len(scored_docs))
|
||||
for i, sd := range scored_docs {
|
||||
results[i] = SearchResult{
|
||||
Action: idx.actions[sd.idx],
|
||||
Score: sd.score,
|
||||
}
|
||||
}
|
||||
|
||||
return results
|
||||
}
|
||||
|
||||
// tokenize extracts searchable tokens from an action.
|
||||
func tokenize(a Action) []string {
|
||||
var parts []string
|
||||
parts = append(parts, strings.Fields(strings.ToLower(a.Name))...)
|
||||
parts = append(parts, strings.Fields(strings.ToLower(a.Category))...)
|
||||
parts = append(parts, strings.Fields(strings.ToLower(a.Description))...)
|
||||
for _, p := range a.Params {
|
||||
parts = append(parts, strings.Fields(strings.ToLower(p.Name))...)
|
||||
parts = append(parts, strings.Fields(strings.ToLower(p.Description))...)
|
||||
}
|
||||
// Split compound names (e.g. "read_inbox" -> "read", "inbox").
|
||||
var expanded []string
|
||||
for _, p := range parts {
|
||||
expanded = append(expanded, p)
|
||||
if strings.Contains(p, "_") {
|
||||
expanded = append(expanded, strings.Split(p, "_")...)
|
||||
}
|
||||
if strings.Contains(p, "-") {
|
||||
expanded = append(expanded, strings.Split(p, "-")...)
|
||||
}
|
||||
}
|
||||
return expanded
|
||||
}
|
||||
|
||||
// termFrequency counts occurrences of each term in a token list.
|
||||
func termFrequency(tokens []string) map[string]int {
|
||||
tf := make(map[string]int)
|
||||
for _, t := range tokens {
|
||||
tf[t]++
|
||||
}
|
||||
return tf
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
package actions
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRegistry_List(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
actions := reg.List()
|
||||
if len(actions) == 0 {
|
||||
t.Fatal("expected actions to be registered")
|
||||
}
|
||||
|
||||
// Check that core actions exist
|
||||
expectedNames := []string{
|
||||
"read_inbox", "claim_messages", "mark_done", "search_messages",
|
||||
"discover_agents", "create_channel", "join_channel", "list_channels",
|
||||
"send_channel_message", "post_task", "upload_attachment",
|
||||
}
|
||||
nameSet := make(map[string]bool)
|
||||
for _, a := range actions {
|
||||
nameSet[a.Name] = true
|
||||
}
|
||||
for _, name := range expectedNames {
|
||||
if !nameSet[name] {
|
||||
t.Errorf("expected action %q in registry", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistry_Get(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
|
||||
t.Run("existing action", func(t *testing.T) {
|
||||
a, ok := reg.Get("read_inbox")
|
||||
if !ok {
|
||||
t.Fatal("expected to find read_inbox")
|
||||
}
|
||||
if a.Category != "messaging" {
|
||||
t.Errorf("category = %q, want messaging", a.Category)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing action", func(t *testing.T) {
|
||||
_, ok := reg.Get("nonexistent")
|
||||
if ok {
|
||||
t.Error("expected not found for nonexistent action")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestIndex_Search(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
idx := NewIndex(reg.List())
|
||||
|
||||
t.Run("messaging query", func(t *testing.T) {
|
||||
results := idx.Search("read inbox messages", 5)
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected results for 'read inbox messages'")
|
||||
}
|
||||
// read_inbox should be the top result
|
||||
if results[0].Action.Name != "read_inbox" {
|
||||
t.Errorf("top result = %q, want read_inbox", results[0].Action.Name)
|
||||
}
|
||||
if results[0].Score <= 0 {
|
||||
t.Error("expected positive relevance score")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("channel query", func(t *testing.T) {
|
||||
results := idx.Search("create channel", 5)
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected results for 'create channel'")
|
||||
}
|
||||
foundCreateChannel := false
|
||||
for _, r := range results {
|
||||
if r.Action.Name == "create_channel" {
|
||||
foundCreateChannel = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !foundCreateChannel {
|
||||
t.Error("expected create_channel in results")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("swarm query", func(t *testing.T) {
|
||||
results := idx.Search("task auction bid", 5)
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected results for 'task auction bid'")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty query returns all", func(t *testing.T) {
|
||||
results := idx.Search("", 20)
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected results for empty query")
|
||||
}
|
||||
// Should return all registered actions (up to limit)
|
||||
totalActions := len(reg.List())
|
||||
if len(results) > 20 {
|
||||
t.Errorf("returned %d results but limit is 20", len(results))
|
||||
}
|
||||
if totalActions <= 20 && len(results) != totalActions {
|
||||
t.Errorf("expected %d results in browse mode, got %d", totalActions, len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("limit enforced", func(t *testing.T) {
|
||||
results := idx.Search("message", 2)
|
||||
if len(results) > 2 {
|
||||
t.Errorf("expected at most 2 results, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("max limit capped at 20", func(t *testing.T) {
|
||||
results := idx.Search("", 100)
|
||||
if len(results) > 20 {
|
||||
t.Errorf("expected at most 20 results, got %d", len(results))
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,459 @@
|
||||
package actions
|
||||
|
||||
// Registry holds all action definitions and supports lookup.
|
||||
type Registry struct {
|
||||
actions map[string]Action
|
||||
ordered []Action // maintains insertion order
|
||||
}
|
||||
|
||||
// NewRegistry creates a registry pre-populated with all 23 agent-callable actions.
|
||||
func NewRegistry() *Registry {
|
||||
r := &Registry{
|
||||
actions: make(map[string]Action, 23),
|
||||
}
|
||||
for _, a := range allActions() {
|
||||
r.actions[a.Name] = a
|
||||
r.ordered = append(r.ordered, a)
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// Get returns an action by name.
|
||||
func (r *Registry) Get(name string) (Action, bool) {
|
||||
a, ok := r.actions[name]
|
||||
return a, ok
|
||||
}
|
||||
|
||||
// List returns all registered actions.
|
||||
func (r *Registry) List() []Action {
|
||||
out := make([]Action, len(r.ordered))
|
||||
copy(out, r.ordered)
|
||||
return out
|
||||
}
|
||||
|
||||
// ListByCategory returns actions in the given category.
|
||||
func (r *Registry) ListByCategory(category string) []Action {
|
||||
var out []Action
|
||||
for _, a := range r.ordered {
|
||||
if a.Category == category {
|
||||
out = append(out, a)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// allActions returns the canonical list of all 23 agent-callable actions.
|
||||
func allActions() []Action {
|
||||
return []Action{
|
||||
// ── Messaging (7 actions) ──────────────────────────────────────
|
||||
{
|
||||
Name: "my_status",
|
||||
Category: "messaging",
|
||||
Description: "Get your complete status overview — identity, pending messages, channel mentions, system notifications, and statistics. Call this first when connecting to SynapBus.",
|
||||
Params: []Param{},
|
||||
Returns: "JSON with agent identity, direct_messages, mentions, system_notifications, channels, and stats",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Check your full status on connect",
|
||||
Code: `call("my_status", {})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "send_message",
|
||||
Category: "messaging",
|
||||
Description: "Send a direct message to another agent. Use discover_agents first to find available agents you can communicate with. For channel messages, use send_channel_message instead.",
|
||||
Params: []Param{
|
||||
{Name: "to", Type: "string", Description: "Name of the recipient agent (required for DMs, omit for channel messages)"},
|
||||
{Name: "body", Type: "string", Description: "Message body text", Required: true},
|
||||
{Name: "subject", Type: "string", Description: "Conversation subject (optional)"},
|
||||
{Name: "priority", Type: "number", Description: "Message priority (1-10, default 5)", Default: "5"},
|
||||
{Name: "metadata", Type: "string", Description: "JSON metadata object (optional)"},
|
||||
{Name: "channel_id", Type: "number", Description: "Channel ID for channel messages (optional)"},
|
||||
{Name: "reply_to", Type: "number", Description: "ID of the message to reply to (optional, for threading)"},
|
||||
},
|
||||
Returns: "JSON with message_id, conversation_id, and status",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Send a direct message to another agent",
|
||||
Code: `call("send_message", {"to": "data-processor", "body": "Please analyze the Q4 sales data", "subject": "Q4 Analysis", "priority": 7})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "read_inbox",
|
||||
Category: "messaging",
|
||||
Description: "Check your message inbox for pending messages. Call this first when connecting to see if other agents have sent you messages. Returns unread/pending direct messages addressed to you.",
|
||||
Params: []Param{
|
||||
{Name: "limit", Type: "number", Description: "Maximum number of messages to return (default 50)", Default: "50"},
|
||||
{Name: "status_filter", Type: "string", Description: "Filter by message status: pending, processing, done, failed"},
|
||||
{Name: "include_read", Type: "boolean", Description: "Include previously read messages (default false)", Default: "false"},
|
||||
{Name: "min_priority", Type: "number", Description: "Minimum priority filter (1-10)"},
|
||||
{Name: "from_agent", Type: "string", Description: "Filter by sender agent name"},
|
||||
},
|
||||
Returns: "JSON with messages array and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Check for new messages",
|
||||
Code: `call("read_inbox", {})`,
|
||||
},
|
||||
{
|
||||
Description: "Read high-priority messages from a specific agent",
|
||||
Code: `call("read_inbox", {"min_priority": 8, "from_agent": "coordinator"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "claim_messages",
|
||||
Category: "messaging",
|
||||
Description: "Atomically claim pending messages for processing",
|
||||
Params: []Param{
|
||||
{Name: "limit", Type: "number", Description: "Maximum number of messages to claim (default 10)", Default: "10"},
|
||||
},
|
||||
Returns: "JSON with claimed messages array and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Claim up to 5 messages for processing",
|
||||
Code: `call("claim_messages", {"limit": 5})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "mark_done",
|
||||
Category: "messaging",
|
||||
Description: "Mark a claimed message as done or failed",
|
||||
Params: []Param{
|
||||
{Name: "message_id", Type: "number", Description: "ID of the message to mark", Required: true},
|
||||
{Name: "status", Type: "string", Description: "New status: 'done' or 'failed' (default 'done')", Default: "done"},
|
||||
{Name: "reason", Type: "string", Description: "Failure reason (only for status='failed')"},
|
||||
},
|
||||
Returns: "JSON with message_id and status",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Mark a message as successfully processed",
|
||||
Code: `call("mark_done", {"message_id": 42})`,
|
||||
},
|
||||
{
|
||||
Description: "Mark a message as failed with reason",
|
||||
Code: `call("mark_done", {"message_id": 42, "status": "failed", "reason": "invalid data format"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "search_messages",
|
||||
Category: "messaging",
|
||||
Description: "Search for messages across your inbox and channels you are a member of. Supports full-text and semantic search (if configured). Use with an empty query to browse recent messages, or provide a natural-language query to find relevant conversations.",
|
||||
Params: []Param{
|
||||
{Name: "query", Type: "string", Description: "Search query string — supports natural language for semantic search"},
|
||||
{Name: "limit", Type: "number", Description: "Maximum results to return (default 10, max 100)", Default: "10"},
|
||||
{Name: "min_priority", Type: "number", Description: "Minimum priority filter (1-10)"},
|
||||
{Name: "from_agent", Type: "string", Description: "Filter by sender agent name"},
|
||||
{Name: "status", Type: "string", Description: "Filter by message status"},
|
||||
{Name: "search_mode", Type: "string", Description: "Search mode: 'auto' (default), 'semantic', or 'fulltext'", Default: "auto"},
|
||||
{Name: "semantic", Type: "boolean", Description: "Force semantic search (shorthand for search_mode='semantic')"},
|
||||
},
|
||||
Returns: "JSON with results array, count, and search_mode used",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Search for messages about deployment",
|
||||
Code: `call("search_messages", {"query": "deployment status update", "limit": 5})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "discover_agents",
|
||||
Category: "messaging",
|
||||
Description: "Discover other agents on the bus. Call this to find agents you can communicate with. Optionally filter by capability keywords, or omit the query to list all registered agents.",
|
||||
Params: []Param{
|
||||
{Name: "query", Type: "string", Description: "Capability keyword to search for"},
|
||||
},
|
||||
Returns: "JSON with agents array (name, display_name, type, capabilities, status) and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "List all available agents",
|
||||
Code: `call("discover_agents", {})`,
|
||||
},
|
||||
{
|
||||
Description: "Find agents with data analysis capabilities",
|
||||
Code: `call("discover_agents", {"query": "data analysis"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
|
||||
// ── Channels (9 actions) ──────────────────────────────────────
|
||||
{
|
||||
Name: "create_channel",
|
||||
Category: "channels",
|
||||
Description: "Create a new channel for group communication",
|
||||
Params: []Param{
|
||||
{Name: "name", Type: "string", Description: "Unique channel name (alphanumeric, hyphens, underscores, max 64 chars)", Required: true},
|
||||
{Name: "description", Type: "string", Description: "Channel description"},
|
||||
{Name: "topic", Type: "string", Description: "Current channel topic"},
|
||||
{Name: "type", Type: "string", Description: "Channel type: 'standard', 'blackboard', or 'auction' (default 'standard')", Default: "standard"},
|
||||
{Name: "is_private", Type: "boolean", Description: "Whether the channel is private (invite-only). Default false", Default: "false"},
|
||||
},
|
||||
Returns: "JSON with channel_id, name, description, topic, type, is_private, created_by",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Create a public channel for project discussion",
|
||||
Code: `call("create_channel", {"name": "project-alpha", "description": "Discussion for Project Alpha", "topic": "Sprint planning"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "join_channel",
|
||||
Category: "channels",
|
||||
Description: "Join a channel to participate in group conversations. You will receive messages sent to the channel after joining. Use list_channels first to see available channels.",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel to join"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel to join (alternative to channel_id)"},
|
||||
},
|
||||
Returns: "JSON with channel_id and status 'joined'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Join a channel by name",
|
||||
Code: `call("join_channel", {"channel_name": "project-alpha"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "leave_channel",
|
||||
Category: "channels",
|
||||
Description: "Leave a channel you are a member of",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel to leave"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel to leave (alternative to channel_id)"},
|
||||
},
|
||||
Returns: "JSON with channel_id and status 'left'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Leave a channel by name",
|
||||
Code: `call("leave_channel", {"channel_name": "project-alpha"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "list_channels",
|
||||
Category: "channels",
|
||||
Description: "List all channels visible to you. Call this when connecting to see available channels and join conversations. Shows all public channels plus private channels you are a member of or have been invited to.",
|
||||
Params: []Param{},
|
||||
Returns: "JSON with channels array (id, name, description, topic, type, is_private, created_by, member_count) and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "List all available channels",
|
||||
Code: `call("list_channels", {})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "invite_to_channel",
|
||||
Category: "channels",
|
||||
Description: "Invite an agent to a channel (only the channel owner can invite to private channels)",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel (alternative to channel_id)"},
|
||||
{Name: "agent_name", Type: "string", Description: "Name of the agent to invite", Required: true},
|
||||
},
|
||||
Returns: "JSON with channel_id, agent_name, and status 'invited'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Invite an agent to a private channel",
|
||||
Code: `call("invite_to_channel", {"channel_name": "secret-ops", "agent_name": "data-processor"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "kick_from_channel",
|
||||
Category: "channels",
|
||||
Description: "Remove an agent from a channel (only the channel owner can kick)",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel (alternative to channel_id)"},
|
||||
{Name: "agent_name", Type: "string", Description: "Name of the agent to kick", Required: true},
|
||||
},
|
||||
Returns: "JSON with channel_id, agent_name, and status 'kicked'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Remove an agent from a channel",
|
||||
Code: `call("kick_from_channel", {"channel_name": "project-alpha", "agent_name": "spambot"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "get_channel_messages",
|
||||
Category: "channels",
|
||||
Description: "Get recent messages from a channel you are a member of",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel (alternative to channel_id)"},
|
||||
{Name: "limit", Type: "number", Description: "Max number of messages to return (default 50, max 200)", Default: "50"},
|
||||
},
|
||||
Returns: "JSON with channel_id, messages array, and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Get recent messages from a channel",
|
||||
Code: `call("get_channel_messages", {"channel_name": "project-alpha", "limit": 20})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "send_channel_message",
|
||||
Category: "channels",
|
||||
Description: "Send a message to all members of a channel. Use @agentname in the body to mention specific agents. You must be a member of the channel to send messages.",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel (alternative to channel_id)"},
|
||||
{Name: "body", Type: "string", Description: "Message body text", Required: true},
|
||||
{Name: "priority", Type: "number", Description: "Message priority (1-10, default 5)", Default: "5"},
|
||||
{Name: "metadata", Type: "string", Description: "JSON metadata object (optional)"},
|
||||
{Name: "reply_to", Type: "number", Description: "Message ID to reply to (creates a thread)", Required: false},
|
||||
},
|
||||
Returns: "JSON with channel_id, message_id, and status 'sent'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Send a message to a channel with a mention",
|
||||
Code: `call("send_channel_message", {"channel_name": "project-alpha", "body": "Hey @coordinator, the build is ready for review"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "update_channel",
|
||||
Category: "channels",
|
||||
Description: "Update channel topic or description (only the channel owner can update)",
|
||||
Params: []Param{
|
||||
{Name: "channel_id", Type: "number", Description: "ID of the channel"},
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the channel (alternative to channel_id)"},
|
||||
{Name: "topic", Type: "string", Description: "New channel topic"},
|
||||
{Name: "description", Type: "string", Description: "New channel description"},
|
||||
},
|
||||
Returns: "JSON with channel_id, name, description, and topic",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Update a channel's topic",
|
||||
Code: `call("update_channel", {"channel_name": "project-alpha", "topic": "v2.0 release planning"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
|
||||
// ── Swarm (5 actions) ─────────────────────────────────────────
|
||||
{
|
||||
Name: "post_task",
|
||||
Category: "swarm",
|
||||
Description: "Post a task to an auction channel for agents to bid on",
|
||||
Params: []Param{
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the auction channel", Required: true},
|
||||
{Name: "title", Type: "string", Description: "Task title", Required: true},
|
||||
{Name: "description", Type: "string", Description: "Task description"},
|
||||
{Name: "requirements", Type: "string", Description: "JSON object of task requirements"},
|
||||
{Name: "deadline", Type: "string", Description: "Task deadline in ISO 8601 format (e.g. 2026-03-13T15:00:00Z)"},
|
||||
},
|
||||
Returns: "JSON with task_id, channel_id, title, status, posted_by, deadline, created_at",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Post a data analysis task to an auction channel",
|
||||
Code: `call("post_task", {"channel_name": "task-marketplace", "title": "Analyze Q4 revenue", "description": "Run trend analysis on Q4 revenue data", "deadline": "2026-03-20T17:00:00Z"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "bid_task",
|
||||
Category: "swarm",
|
||||
Description: "Submit a bid on an open task in an auction channel",
|
||||
Params: []Param{
|
||||
{Name: "task_id", Type: "number", Description: "ID of the task to bid on", Required: true},
|
||||
{Name: "capabilities", Type: "string", Description: "JSON object describing your relevant capabilities"},
|
||||
{Name: "time_estimate", Type: "string", Description: "Estimated time to complete the task"},
|
||||
{Name: "message", Type: "string", Description: "Message to the task poster explaining your bid"},
|
||||
},
|
||||
Returns: "JSON with bid_id, task_id, agent_name, time_estimate, status",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Bid on a task with capabilities and time estimate",
|
||||
Code: `call("bid_task", {"task_id": 7, "capabilities": "{\"skills\": [\"data-analysis\", \"python\"]}", "time_estimate": "2 hours", "message": "I have experience with revenue trend analysis"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "accept_bid",
|
||||
Category: "swarm",
|
||||
Description: "Accept a bid on a task you posted, assigning the task to the bidding agent",
|
||||
Params: []Param{
|
||||
{Name: "task_id", Type: "number", Description: "ID of the task", Required: true},
|
||||
{Name: "bid_id", Type: "number", Description: "ID of the bid to accept", Required: true},
|
||||
},
|
||||
Returns: "JSON with task_id, bid_id, and status 'accepted'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Accept a bid on your task",
|
||||
Code: `call("accept_bid", {"task_id": 7, "bid_id": 3})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "complete_task",
|
||||
Category: "swarm",
|
||||
Description: "Mark a task as completed (only the assigned agent can do this)",
|
||||
Params: []Param{
|
||||
{Name: "task_id", Type: "number", Description: "ID of the task to complete", Required: true},
|
||||
},
|
||||
Returns: "JSON with task_id and status 'completed'",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Mark an assigned task as completed",
|
||||
Code: `call("complete_task", {"task_id": 7})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "list_tasks",
|
||||
Category: "swarm",
|
||||
Description: "List tasks in an auction channel, optionally filtered by status",
|
||||
Params: []Param{
|
||||
{Name: "channel_name", Type: "string", Description: "Name of the auction channel", Required: true},
|
||||
{Name: "status", Type: "string", Description: "Filter by task status: open, assigned, completed, cancelled"},
|
||||
},
|
||||
Returns: "JSON with tasks array (id, title, description, status, posted_by, assigned_to, deadline, created_at) and count",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "List open tasks in an auction channel",
|
||||
Code: `call("list_tasks", {"channel_name": "task-marketplace", "status": "open"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
|
||||
// ── Attachments (2 actions) ───────────────────────────────────
|
||||
{
|
||||
Name: "upload_attachment",
|
||||
Category: "attachments",
|
||||
Description: "Upload a file attachment. Content must be base64-encoded. Returns the SHA-256 hash for later retrieval. Max file size: 50MB.",
|
||||
Params: []Param{
|
||||
{Name: "content", Type: "string", Description: "Base64-encoded file content", Required: true},
|
||||
{Name: "filename", Type: "string", Description: "Original filename (optional, used for MIME detection and display)"},
|
||||
{Name: "mime_type", Type: "string", Description: "MIME type override (optional, auto-detected from content if not provided)"},
|
||||
{Name: "message_id", Type: "number", Description: "Message ID to attach the file to (optional, can be linked later)"},
|
||||
},
|
||||
Returns: "JSON with hash, size, mime_type, original_filename",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Upload a text file attachment",
|
||||
Code: `call("upload_attachment", {"content": "SGVsbG8gV29ybGQ=", "filename": "hello.txt", "mime_type": "text/plain"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "download_attachment",
|
||||
Category: "attachments",
|
||||
Description: "Download an attachment by its SHA-256 hash. Returns base64-encoded content along with filename and MIME type metadata.",
|
||||
Params: []Param{
|
||||
{Name: "hash", Type: "string", Description: "SHA-256 hash of the attachment", Required: true},
|
||||
},
|
||||
Returns: "JSON with hash, content (base64), original_filename, mime_type, size",
|
||||
Examples: []Example{
|
||||
{
|
||||
Description: "Download an attachment by hash",
|
||||
Code: `call("download_attachment", {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"})`,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package actions
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRegistryHas23Actions(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
got := len(r.List())
|
||||
if got != 23 {
|
||||
t.Errorf("expected 23 actions, got %d", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryCategories(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
|
||||
tests := []struct {
|
||||
category string
|
||||
want int
|
||||
}{
|
||||
{"messaging", 7},
|
||||
{"channels", 9},
|
||||
{"swarm", 5},
|
||||
{"attachments", 2},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.category, func(t *testing.T) {
|
||||
got := len(r.ListByCategory(tt.category))
|
||||
if got != tt.want {
|
||||
t.Errorf("category %q: expected %d actions, got %d", tt.category, tt.want, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryGetByName(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
|
||||
allNames := []string{
|
||||
// messaging
|
||||
"my_status", "send_message", "read_inbox", "claim_messages", "mark_done", "search_messages", "discover_agents",
|
||||
// channels
|
||||
"create_channel", "join_channel", "leave_channel", "list_channels",
|
||||
"invite_to_channel", "kick_from_channel", "get_channel_messages",
|
||||
"send_channel_message", "update_channel",
|
||||
// swarm
|
||||
"post_task", "bid_task", "accept_bid", "complete_task", "list_tasks",
|
||||
// attachments
|
||||
"upload_attachment", "download_attachment",
|
||||
}
|
||||
|
||||
for _, name := range allNames {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
a, ok := r.Get(name)
|
||||
if !ok {
|
||||
t.Fatalf("action %q not found in registry", name)
|
||||
}
|
||||
if a.Name != name {
|
||||
t.Errorf("expected name %q, got %q", name, a.Name)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryGetNotFound(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
_, ok := r.Get("nonexistent_action")
|
||||
if ok {
|
||||
t.Error("expected Get to return false for nonexistent action")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryActionsHaveExamples(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
for _, a := range r.List() {
|
||||
t.Run(a.Name, func(t *testing.T) {
|
||||
if len(a.Examples) == 0 {
|
||||
t.Errorf("action %q has no examples", a.Name)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryActionsHaveDescriptions(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
for _, a := range r.List() {
|
||||
t.Run(a.Name, func(t *testing.T) {
|
||||
if a.Description == "" {
|
||||
t.Errorf("action %q has empty description", a.Name)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryActionsHaveReturns(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
for _, a := range r.List() {
|
||||
t.Run(a.Name, func(t *testing.T) {
|
||||
if a.Returns == "" {
|
||||
t.Errorf("action %q has empty Returns field", a.Name)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryListByUnknownCategory(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
got := r.ListByCategory("nonexistent")
|
||||
if len(got) != 0 {
|
||||
t.Errorf("expected 0 actions for unknown category, got %d", len(got))
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryListReturnsCopy(t *testing.T) {
|
||||
r := NewRegistry()
|
||||
list1 := r.List()
|
||||
list2 := r.List()
|
||||
// Mutating the first list should not affect the second.
|
||||
if len(list1) > 0 {
|
||||
list1[0].Name = "mutated"
|
||||
if list2[0].Name == "mutated" {
|
||||
t.Error("List() should return a copy, not a reference to internal slice")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
package actions
|
||||
|
||||
// Action represents a callable operation in the system.
|
||||
type Action struct {
|
||||
Name string `json:"name"`
|
||||
Category string `json:"category"` // messaging, channels, swarm, attachments
|
||||
Description string `json:"description"`
|
||||
Params []Param `json:"params"`
|
||||
Returns string `json:"returns"` // Human-readable return description
|
||||
Examples []Example `json:"examples"`
|
||||
}
|
||||
|
||||
// Param describes an action parameter.
|
||||
type Param struct {
|
||||
Name string `json:"name"`
|
||||
Type string `json:"type"` // string, number, boolean
|
||||
Description string `json:"description"`
|
||||
Required bool `json:"required"`
|
||||
Default string `json:"default,omitempty"`
|
||||
}
|
||||
|
||||
// Example shows a usage example for the action.
|
||||
type Example struct {
|
||||
Description string `json:"description"`
|
||||
Code string `json:"code"` // JS code example using call()
|
||||
}
|
||||
@@ -2,6 +2,7 @@
|
||||
package admin
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"log/slog"
|
||||
"net"
|
||||
@@ -10,11 +11,27 @@ import (
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
"github.com/synapbus/synapbus/internal/auth"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/k8s"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
"github.com/synapbus/synapbus/internal/webhooks"
|
||||
)
|
||||
|
||||
// WebhookServiceProvider defines the webhook operations needed by the admin socket.
|
||||
type WebhookServiceProvider interface {
|
||||
RegisterWebhook(ctx context.Context, agentName, url string, events []string, secret string) (*webhooks.Webhook, error)
|
||||
ListWebhooks(ctx context.Context, agentName string) ([]*webhooks.Webhook, error)
|
||||
DeleteWebhook(ctx context.Context, agentName string, webhookID int64) error
|
||||
}
|
||||
|
||||
// K8sServiceProvider defines the K8s handler operations needed by the admin socket.
|
||||
type K8sServiceProvider interface {
|
||||
RegisterHandler(ctx context.Context, agentName string, req k8s.RegisterHandlerRequest) (*k8s.K8sHandler, error)
|
||||
ListHandlers(ctx context.Context, agentName string) ([]*k8s.K8sHandler, error)
|
||||
DeleteHandler(ctx context.Context, agentName string, handlerID int64) error
|
||||
}
|
||||
|
||||
// Services holds references to all services the admin socket can control.
|
||||
type Services struct {
|
||||
Users *auth.SQLiteUserStore
|
||||
@@ -27,6 +44,8 @@ type Services struct {
|
||||
VectorIndex *search.VectorIndex
|
||||
SearchService *search.Service
|
||||
AttachmentService *attachments.Service
|
||||
WebhookService WebhookServiceProvider
|
||||
K8sService K8sServiceProvider
|
||||
DataDir string
|
||||
RetentionWorker RetentionStatusProvider
|
||||
}
|
||||
|
||||
@@ -13,6 +13,8 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/k8s"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
@@ -137,6 +139,8 @@ func (s *AdminServer) dispatch(req Request) Response {
|
||||
return s.handleAgentDelete(ctx, req.Args)
|
||||
case "agent.revoke_key":
|
||||
return s.handleAgentRevokeKey(ctx, req.Args)
|
||||
case "agent.update_capabilities":
|
||||
return s.handleAgentUpdateCapabilities(ctx, req.Args)
|
||||
|
||||
// --- audit commands ---
|
||||
case "audit.list":
|
||||
@@ -161,6 +165,10 @@ func (s *AdminServer) dispatch(req Request) Response {
|
||||
return s.handleChannelsList(ctx)
|
||||
case "channels.show":
|
||||
return s.handleChannelsShow(ctx, req.Args)
|
||||
case "channels.create":
|
||||
return s.handleChannelsCreate(ctx, req.Args)
|
||||
case "channels.join":
|
||||
return s.handleChannelsJoin(ctx, req.Args)
|
||||
|
||||
// --- conversations ---
|
||||
case "conversations.list":
|
||||
@@ -188,6 +196,26 @@ func (s *AdminServer) dispatch(req Request) Response {
|
||||
case "retention.status":
|
||||
return s.handleRetentionStatus(ctx)
|
||||
|
||||
// --- webhooks ---
|
||||
case "webhook.register":
|
||||
return s.handleWebhookRegister(ctx, req.Args)
|
||||
case "webhook.list":
|
||||
return s.handleWebhookList(ctx, req.Args)
|
||||
case "webhook.delete":
|
||||
return s.handleWebhookDelete(ctx, req.Args)
|
||||
|
||||
// --- k8s ---
|
||||
case "k8s.register":
|
||||
return s.handleK8sRegister(ctx, req.Args)
|
||||
case "k8s.list":
|
||||
return s.handleK8sList(ctx, req.Args)
|
||||
case "k8s.delete":
|
||||
return s.handleK8sDelete(ctx, req.Args)
|
||||
|
||||
// --- attachments ---
|
||||
case "attachments.gc":
|
||||
return s.handleAttachmentsGC(ctx)
|
||||
|
||||
default:
|
||||
return Response{OK: false, Error: fmt.Sprintf("unknown command: %s", req.Command)}
|
||||
}
|
||||
@@ -420,6 +448,35 @@ func (s *AdminServer) handleAgentRevokeKey(ctx context.Context, args json.RawMes
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleAgentUpdateCapabilities(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
Name string `json:"name"`
|
||||
Capabilities json.RawMessage `json:"capabilities"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.Name == "" {
|
||||
return Response{OK: false, Error: "name is required"}
|
||||
}
|
||||
if len(p.Capabilities) == 0 {
|
||||
return Response{OK: false, Error: "capabilities is required"}
|
||||
}
|
||||
if !json.Valid(p.Capabilities) {
|
||||
return Response{OK: false, Error: "capabilities must be valid JSON"}
|
||||
}
|
||||
|
||||
agent, err := s.services.Agents.UpdateAgent(ctx, p.Name, "", p.Capabilities)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"name": agent.Name,
|
||||
"capabilities": json.RawMessage(agent.Capabilities),
|
||||
}}
|
||||
}
|
||||
|
||||
// ---------- audit handlers ----------
|
||||
|
||||
func (s *AdminServer) handleAuditList(ctx context.Context, args json.RawMessage) Response {
|
||||
@@ -866,6 +923,78 @@ func (s *AdminServer) handleChannelsShow(ctx context.Context, args json.RawMessa
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleChannelsCreate(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.Name == "" {
|
||||
return Response{OK: false, Error: "name is required"}
|
||||
}
|
||||
|
||||
ch, err := s.services.Channels.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: p.Name,
|
||||
Description: p.Description,
|
||||
Type: "standard",
|
||||
CreatedBy: "system",
|
||||
})
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"type": ch.Type,
|
||||
"is_private": ch.IsPrivate,
|
||||
"created_by": ch.CreatedBy,
|
||||
"created_at": ch.CreatedAt.Format(time.RFC3339),
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleChannelsJoin(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
Channel string `json:"channel"`
|
||||
Agent string `json:"agent"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.Channel == "" {
|
||||
return Response{OK: false, Error: "channel is required"}
|
||||
}
|
||||
if p.Agent == "" {
|
||||
return Response{OK: false, Error: "agent is required"}
|
||||
}
|
||||
|
||||
ch, err := s.services.Channels.GetChannelByName(ctx, p.Channel)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: fmt.Sprintf("channel not found: %s", p.Channel)}
|
||||
}
|
||||
|
||||
// Check if already a member for status reporting
|
||||
isMember, _ := s.services.Channels.IsMember(ctx, ch.ID, p.Agent)
|
||||
|
||||
if err := s.services.Channels.JoinChannel(ctx, ch.ID, p.Agent); err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
status := "joined"
|
||||
if isMember {
|
||||
status = "already_member"
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"channel": p.Channel,
|
||||
"agent": p.Agent,
|
||||
"status": status,
|
||||
}}
|
||||
}
|
||||
|
||||
// ---------- conversations handlers ----------
|
||||
|
||||
func (s *AdminServer) handleConversationsList(ctx context.Context, args json.RawMessage) Response {
|
||||
@@ -1139,5 +1268,368 @@ func (s *AdminServer) handleRetentionStatus(ctx context.Context) Response {
|
||||
}}
|
||||
}
|
||||
|
||||
// ---------- webhook handlers ----------
|
||||
|
||||
func (s *AdminServer) handleWebhookRegister(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
URL string `json:"url"`
|
||||
Events string `json:"events"`
|
||||
Secret string `json:"secret"`
|
||||
AgentName string `json:"agent_name"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.URL == "" || p.Events == "" || p.Secret == "" || p.AgentName == "" {
|
||||
return Response{OK: false, Error: "url, events, secret, and agent_name are required"}
|
||||
}
|
||||
|
||||
if s.services.WebhookService == nil {
|
||||
return Response{OK: false, Error: "webhook service not configured"}
|
||||
}
|
||||
|
||||
events := strings.Split(p.Events, ",")
|
||||
for i := range events {
|
||||
events[i] = strings.TrimSpace(events[i])
|
||||
}
|
||||
|
||||
wh, err := s.services.WebhookService.RegisterWebhook(ctx, p.AgentName, p.URL, events, p.Secret)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"id": wh.ID,
|
||||
"url": wh.URL,
|
||||
"events": wh.Events,
|
||||
"status": wh.Status,
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleWebhookList(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
AgentName string `json:"agent_name"`
|
||||
}
|
||||
if args != nil {
|
||||
json.Unmarshal(args, &p)
|
||||
}
|
||||
|
||||
if s.services.WebhookService == nil {
|
||||
return Response{OK: false, Error: "webhook service not configured"}
|
||||
}
|
||||
|
||||
if p.AgentName == "" {
|
||||
// Admin: list all webhooks by querying DB directly.
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, agent_name, url, events, status, consecutive_failures, created_at
|
||||
FROM webhooks ORDER BY created_at DESC`)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type whRow struct {
|
||||
ID int64 `json:"id"`
|
||||
AgentName string `json:"agent_name"`
|
||||
URL string `json:"url"`
|
||||
Events []string `json:"events"`
|
||||
Status string `json:"status"`
|
||||
ConsecutiveFailures int `json:"consecutive_failures"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
var result []whRow
|
||||
for rows.Next() {
|
||||
var r whRow
|
||||
var eventsJSON string
|
||||
var createdAt time.Time
|
||||
if err := rows.Scan(&r.ID, &r.AgentName, &r.URL, &eventsJSON, &r.Status, &r.ConsecutiveFailures, &createdAt); err != nil {
|
||||
return Response{OK: false, Error: "scan: " + err.Error()}
|
||||
}
|
||||
json.Unmarshal([]byte(eventsJSON), &r.Events)
|
||||
if r.Events == nil {
|
||||
r.Events = []string{}
|
||||
}
|
||||
r.CreatedAt = createdAt.Format(time.RFC3339)
|
||||
result = append(result, r)
|
||||
}
|
||||
if result == nil {
|
||||
result = []whRow{}
|
||||
}
|
||||
return Response{OK: true, Data: result}
|
||||
}
|
||||
|
||||
webhookList, err := s.services.WebhookService.ListWebhooks(ctx, p.AgentName)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
type whRow struct {
|
||||
ID int64 `json:"id"`
|
||||
AgentName string `json:"agent_name"`
|
||||
URL string `json:"url"`
|
||||
Events []string `json:"events"`
|
||||
Status string `json:"status"`
|
||||
ConsecutiveFailures int `json:"consecutive_failures"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
result := make([]whRow, len(webhookList))
|
||||
for i, wh := range webhookList {
|
||||
result[i] = whRow{
|
||||
ID: wh.ID,
|
||||
AgentName: wh.AgentName,
|
||||
URL: wh.URL,
|
||||
Events: wh.Events,
|
||||
Status: wh.Status,
|
||||
ConsecutiveFailures: wh.ConsecutiveFailures,
|
||||
CreatedAt: wh.CreatedAt.Format(time.RFC3339),
|
||||
}
|
||||
}
|
||||
return Response{OK: true, Data: result}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleWebhookDelete(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
ID int64 `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.ID <= 0 {
|
||||
return Response{OK: false, Error: "id is required"}
|
||||
}
|
||||
|
||||
if s.services.WebhookService == nil {
|
||||
return Response{OK: false, Error: "webhook service not configured"}
|
||||
}
|
||||
|
||||
// Admin bypass: look up the webhook's agent_name first, then delete.
|
||||
var agentName string
|
||||
err := s.db.QueryRowContext(ctx, "SELECT agent_name FROM webhooks WHERE id = ?", p.ID).Scan(&agentName)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: "webhook not found"}
|
||||
}
|
||||
|
||||
if err := s.services.WebhookService.DeleteWebhook(ctx, agentName, p.ID); err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"deleted": p.ID,
|
||||
}}
|
||||
}
|
||||
|
||||
// ---------- k8s handlers ----------
|
||||
|
||||
func (s *AdminServer) handleK8sRegister(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
Image string `json:"image"`
|
||||
Events string `json:"events"`
|
||||
AgentName string `json:"agent_name"`
|
||||
Namespace string `json:"namespace"`
|
||||
ResourcesMemory string `json:"resources_memory"`
|
||||
ResourcesCPU string `json:"resources_cpu"`
|
||||
Env string `json:"env"`
|
||||
TimeoutSeconds int `json:"timeout_seconds"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.Image == "" || p.Events == "" || p.AgentName == "" {
|
||||
return Response{OK: false, Error: "image, events, and agent_name are required"}
|
||||
}
|
||||
|
||||
if s.services.K8sService == nil {
|
||||
return Response{OK: false, Error: "k8s service not configured"}
|
||||
}
|
||||
|
||||
events := strings.Split(p.Events, ",")
|
||||
for i := range events {
|
||||
events[i] = strings.TrimSpace(events[i])
|
||||
}
|
||||
|
||||
// Parse env from comma-separated KEY=VALUE pairs.
|
||||
envMap := map[string]string{}
|
||||
if p.Env != "" {
|
||||
for _, pair := range strings.Split(p.Env, ",") {
|
||||
pair = strings.TrimSpace(pair)
|
||||
parts := strings.SplitN(pair, "=", 2)
|
||||
if len(parts) == 2 {
|
||||
envMap[parts[0]] = parts[1]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
timeout := p.TimeoutSeconds
|
||||
if timeout <= 0 {
|
||||
timeout = 300
|
||||
}
|
||||
|
||||
req := k8s.RegisterHandlerRequest{
|
||||
Image: p.Image,
|
||||
Events: events,
|
||||
Namespace: p.Namespace,
|
||||
ResourcesMemory: p.ResourcesMemory,
|
||||
ResourcesCPU: p.ResourcesCPU,
|
||||
Env: envMap,
|
||||
TimeoutSeconds: timeout,
|
||||
}
|
||||
|
||||
handler, err := s.services.K8sService.RegisterHandler(ctx, p.AgentName, req)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"id": handler.ID,
|
||||
"image": handler.Image,
|
||||
"events": handler.Events,
|
||||
"status": handler.Status,
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleK8sList(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
AgentName string `json:"agent_name"`
|
||||
}
|
||||
if args != nil {
|
||||
json.Unmarshal(args, &p)
|
||||
}
|
||||
|
||||
if s.services.K8sService == nil {
|
||||
return Response{OK: false, Error: "k8s service not configured"}
|
||||
}
|
||||
|
||||
if p.AgentName == "" {
|
||||
// Admin: list all K8s handlers by querying DB directly.
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, agent_name, image, events, namespace, resources_memory, resources_cpu, timeout_seconds, status, created_at
|
||||
FROM k8s_handlers ORDER BY created_at DESC`)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type handlerRow struct {
|
||||
ID int64 `json:"id"`
|
||||
AgentName string `json:"agent_name"`
|
||||
Image string `json:"image"`
|
||||
Events []string `json:"events"`
|
||||
Namespace string `json:"namespace"`
|
||||
ResourcesMemory string `json:"resources_memory"`
|
||||
ResourcesCPU string `json:"resources_cpu"`
|
||||
TimeoutSeconds int `json:"timeout_seconds"`
|
||||
Status string `json:"status"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
var result []handlerRow
|
||||
for rows.Next() {
|
||||
var r handlerRow
|
||||
var eventsJSON string
|
||||
var createdAt time.Time
|
||||
if err := rows.Scan(&r.ID, &r.AgentName, &r.Image, &eventsJSON, &r.Namespace,
|
||||
&r.ResourcesMemory, &r.ResourcesCPU, &r.TimeoutSeconds, &r.Status, &createdAt); err != nil {
|
||||
return Response{OK: false, Error: "scan: " + err.Error()}
|
||||
}
|
||||
json.Unmarshal([]byte(eventsJSON), &r.Events)
|
||||
if r.Events == nil {
|
||||
r.Events = []string{}
|
||||
}
|
||||
r.CreatedAt = createdAt.Format(time.RFC3339)
|
||||
result = append(result, r)
|
||||
}
|
||||
if result == nil {
|
||||
result = []handlerRow{}
|
||||
}
|
||||
return Response{OK: true, Data: result}
|
||||
}
|
||||
|
||||
handlers, err := s.services.K8sService.ListHandlers(ctx, p.AgentName)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
type handlerRow struct {
|
||||
ID int64 `json:"id"`
|
||||
AgentName string `json:"agent_name"`
|
||||
Image string `json:"image"`
|
||||
Events []string `json:"events"`
|
||||
Namespace string `json:"namespace"`
|
||||
ResourcesMemory string `json:"resources_memory"`
|
||||
ResourcesCPU string `json:"resources_cpu"`
|
||||
TimeoutSeconds int `json:"timeout_seconds"`
|
||||
Status string `json:"status"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
result := make([]handlerRow, len(handlers))
|
||||
for i, h := range handlers {
|
||||
result[i] = handlerRow{
|
||||
ID: h.ID,
|
||||
AgentName: h.AgentName,
|
||||
Image: h.Image,
|
||||
Events: h.Events,
|
||||
Namespace: h.Namespace,
|
||||
ResourcesMemory: h.ResourcesMemory,
|
||||
ResourcesCPU: h.ResourcesCPU,
|
||||
TimeoutSeconds: h.TimeoutSeconds,
|
||||
Status: h.Status,
|
||||
CreatedAt: h.CreatedAt.Format(time.RFC3339),
|
||||
}
|
||||
}
|
||||
return Response{OK: true, Data: result}
|
||||
}
|
||||
|
||||
func (s *AdminServer) handleK8sDelete(ctx context.Context, args json.RawMessage) Response {
|
||||
var p struct {
|
||||
ID int64 `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal(args, &p); err != nil {
|
||||
return Response{OK: false, Error: "invalid args: " + err.Error()}
|
||||
}
|
||||
if p.ID <= 0 {
|
||||
return Response{OK: false, Error: "id is required"}
|
||||
}
|
||||
|
||||
if s.services.K8sService == nil {
|
||||
return Response{OK: false, Error: "k8s service not configured"}
|
||||
}
|
||||
|
||||
// Admin bypass: look up the handler's agent_name first, then delete.
|
||||
var agentName string
|
||||
err := s.db.QueryRowContext(ctx, "SELECT agent_name FROM k8s_handlers WHERE id = ?", p.ID).Scan(&agentName)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: "handler not found"}
|
||||
}
|
||||
|
||||
if err := s.services.K8sService.DeleteHandler(ctx, agentName, p.ID); err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"deleted": p.ID,
|
||||
}}
|
||||
}
|
||||
|
||||
// ---------- attachments handlers ----------
|
||||
|
||||
func (s *AdminServer) handleAttachmentsGC(ctx context.Context) Response {
|
||||
if s.services.AttachmentService == nil {
|
||||
return Response{OK: false, Error: "attachment service not configured"}
|
||||
}
|
||||
|
||||
result, err := s.services.AttachmentService.GarbageCollect(ctx)
|
||||
if err != nil {
|
||||
return Response{OK: false, Error: err.Error()}
|
||||
}
|
||||
|
||||
return Response{OK: true, Data: map[string]interface{}{
|
||||
"files_removed": result.FilesRemoved,
|
||||
"bytes_reclaimed": result.BytesReclaimed,
|
||||
}}
|
||||
}
|
||||
|
||||
// Ensure the messaging import is used.
|
||||
var _ = messaging.StatusPending
|
||||
|
||||
@@ -229,9 +229,13 @@ func RequiredAuthMiddlewareWithOAuth(service *AgentService, keyService *apikeys.
|
||||
|
||||
// resolveOAuthToken introspects an OAuth bearer token and extracts agent identity.
|
||||
func resolveOAuthToken(ctx context.Context, provider fosite.OAuth2Provider, token string, service *AgentService) (agentName string, ownerID string, ok bool) {
|
||||
// Use a fositeSession-compatible struct for introspection.
|
||||
// We import the type indirectly through the fosite interface.
|
||||
_, ar, err := provider.IntrospectToken(ctx, token, fosite.AccessToken, &oauthIntrospectSession{})
|
||||
// Decouple from the HTTP request context so token introspection completes
|
||||
// even if the client disconnects (fixes "context canceled" errors during
|
||||
// concurrent MCP connections from claude.ai).
|
||||
dbCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
_, ar, err := provider.IntrospectToken(dbCtx, token, fosite.AccessToken, &oauthIntrospectSession{})
|
||||
if err != nil {
|
||||
return "", "", false
|
||||
}
|
||||
|
||||
@@ -245,6 +245,12 @@ func (s *AgentService) ListAgents(ctx context.Context, ownerID int64) ([]*Agent,
|
||||
return s.store.ListAgentsByOwner(ctx, ownerID)
|
||||
}
|
||||
|
||||
// ListAllActiveAgents returns all active non-human agents across all owners.
|
||||
// Used for the A2A Agent Card discovery endpoint.
|
||||
func (s *AgentService) ListAllActiveAgents(ctx context.Context) ([]*Agent, error) {
|
||||
return s.store.ListAllActiveAgents(ctx)
|
||||
}
|
||||
|
||||
// RevokeKey generates a new API key for an agent. Only the owner can do this.
|
||||
// Returns the agent and the new raw API key (shown once).
|
||||
func (s *AgentService) RevokeKey(ctx context.Context, name string, ownerID int64) (*Agent, string, error) {
|
||||
|
||||
@@ -15,6 +15,7 @@ type AgentStore interface {
|
||||
UpdateAgent(ctx context.Context, agent *Agent) error
|
||||
DeactivateAgent(ctx context.Context, name string) error
|
||||
ListActiveAgents(ctx context.Context) ([]*Agent, error)
|
||||
ListAllActiveAgents(ctx context.Context) ([]*Agent, error)
|
||||
ListAgentsByOwner(ctx context.Context, ownerID int64) ([]*Agent, error)
|
||||
SearchAgentsByCapability(ctx context.Context, query string) ([]*Agent, error)
|
||||
GetHumanAgentByOwner(ctx context.Context, ownerID int64) (*Agent, error)
|
||||
@@ -112,6 +113,18 @@ func (s *SQLiteAgentStore) ListActiveAgents(ctx context.Context) ([]*Agent, erro
|
||||
return s.scanAgents(rows)
|
||||
}
|
||||
|
||||
func (s *SQLiteAgentStore) ListAllActiveAgents(ctx context.Context) ([]*Agent, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, name, display_name, type, capabilities, owner_id, api_key_hash, status, created_at, updated_at
|
||||
FROM agents WHERE status = 'active' AND type != 'human' ORDER BY name`,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
return s.scanAgents(rows)
|
||||
}
|
||||
|
||||
func (s *SQLiteAgentStore) ListAgentsByOwner(ctx context.Context, ownerID int64) ([]*Agent, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, name, display_name, type, capabilities, owner_id, api_key_hash, status, created_at, updated_at
|
||||
|
||||
@@ -0,0 +1,282 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
)
|
||||
|
||||
// AnalyticsHandler serves analytics endpoints for the Web UI dashboard.
|
||||
type AnalyticsHandler struct {
|
||||
db *sql.DB
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewAnalyticsHandler creates a new analytics handler.
|
||||
func NewAnalyticsHandler(db *sql.DB, agentService *agents.AgentService, channelService *channels.Service) *AnalyticsHandler {
|
||||
return &AnalyticsHandler{
|
||||
db: db,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
logger: slog.Default().With("component", "api.analytics"),
|
||||
}
|
||||
}
|
||||
|
||||
// parseSpan parses a span parameter and returns the cutoff time and strftime format string.
|
||||
func parseSpan(span string) (time.Time, string, error) {
|
||||
now := time.Now().UTC()
|
||||
switch span {
|
||||
case "1h":
|
||||
return now.Add(-1 * time.Hour), "%Y-%m-%d %H:%M", nil
|
||||
case "4h":
|
||||
return now.Add(-4 * time.Hour), "%Y-%m-%d %H:%M", nil
|
||||
case "24h":
|
||||
return now.Add(-24 * time.Hour), "%Y-%m-%d %H:00", nil
|
||||
case "7d":
|
||||
return now.Add(-7 * 24 * time.Hour), "%Y-%m-%d", nil
|
||||
case "30d":
|
||||
return now.Add(-30 * 24 * time.Hour), "%Y-%m-%d", nil
|
||||
default:
|
||||
return time.Time{}, "", fmt.Errorf("invalid span: %s (valid: 1h, 4h, 24h, 7d, 30d)", span)
|
||||
}
|
||||
}
|
||||
|
||||
// Timeline handles GET /api/analytics/timeline?span=24h.
|
||||
func (h *AnalyticsHandler) Timeline(w http.ResponseWriter, r *http.Request) {
|
||||
span := r.URL.Query().Get("span")
|
||||
if span == "" {
|
||||
span = "24h"
|
||||
}
|
||||
|
||||
cutoff, strftimeFmt, err := parseSpan(span)
|
||||
if err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_span", err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
// For 1h and 4h spans, bucket by 5-minute intervals using SQL expression
|
||||
var query string
|
||||
if span == "1h" || span == "4h" {
|
||||
// Round minutes down to nearest 5 using printf
|
||||
query = `SELECT strftime('%Y-%m-%d %H:', created_at) || printf('%02d', (CAST(strftime('%M', created_at) AS INTEGER) / 5) * 5) AS bucket, COUNT(*) AS count FROM messages WHERE created_at >= ? GROUP BY bucket ORDER BY bucket`
|
||||
} else {
|
||||
query = `SELECT strftime(?, created_at) AS bucket, COUNT(*) AS count FROM messages WHERE created_at >= ? GROUP BY bucket ORDER BY bucket`
|
||||
}
|
||||
|
||||
type bucket struct {
|
||||
Time string `json:"time"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
|
||||
var buckets []bucket
|
||||
var total int
|
||||
|
||||
cutoffStr := cutoff.Format("2006-01-02 15:04:05")
|
||||
|
||||
var rows *sql.Rows
|
||||
if span == "1h" || span == "4h" {
|
||||
rows, err = h.db.QueryContext(r.Context(), query, cutoffStr)
|
||||
} else {
|
||||
rows, err = h.db.QueryContext(r.Context(), query, strftimeFmt, cutoffStr)
|
||||
}
|
||||
if err != nil {
|
||||
h.logger.Error("timeline query failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to query timeline"))
|
||||
return
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
var b bucket
|
||||
if err := rows.Scan(&b.Time, &b.Count); err != nil {
|
||||
h.logger.Error("timeline scan failed", "error", err)
|
||||
continue
|
||||
}
|
||||
buckets = append(buckets, b)
|
||||
total += b.Count
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
h.logger.Error("timeline rows error", "error", err)
|
||||
}
|
||||
|
||||
if buckets == nil {
|
||||
buckets = []bucket{}
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"span": span,
|
||||
"buckets": buckets,
|
||||
"total": total,
|
||||
})
|
||||
}
|
||||
|
||||
// TopAgents handles GET /api/analytics/top-agents?span=24h&limit=5.
|
||||
func (h *AnalyticsHandler) TopAgents(w http.ResponseWriter, r *http.Request) {
|
||||
span := r.URL.Query().Get("span")
|
||||
if span == "" {
|
||||
span = "24h"
|
||||
}
|
||||
|
||||
cutoff, _, err := parseSpan(span)
|
||||
if err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_span", err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
limit := 5
|
||||
if l := r.URL.Query().Get("limit"); l != "" {
|
||||
if parsed, err := strconv.Atoi(l); err == nil && parsed > 0 {
|
||||
limit = parsed
|
||||
if limit > 100 {
|
||||
limit = 100
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cutoffStr := cutoff.Format("2006-01-02 15:04:05")
|
||||
|
||||
rows, err := h.db.QueryContext(r.Context(),
|
||||
`SELECT from_agent, COUNT(*) as count FROM messages WHERE created_at >= ? AND from_agent != '' GROUP BY from_agent ORDER BY count DESC LIMIT ?`,
|
||||
cutoffStr, limit,
|
||||
)
|
||||
if err != nil {
|
||||
h.logger.Error("top-agents query failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to query top agents"))
|
||||
return
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type agentStat struct {
|
||||
Name string `json:"name"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
|
||||
var agentStats []agentStat
|
||||
for rows.Next() {
|
||||
var s agentStat
|
||||
if err := rows.Scan(&s.Name, &s.Count); err != nil {
|
||||
h.logger.Error("top-agents scan failed", "error", err)
|
||||
continue
|
||||
}
|
||||
|
||||
// Look up display name from agent service
|
||||
if h.agentService != nil {
|
||||
if agent, err := h.agentService.GetAgent(r.Context(), s.Name); err == nil {
|
||||
s.DisplayName = agent.DisplayName
|
||||
}
|
||||
}
|
||||
if s.DisplayName == "" {
|
||||
s.DisplayName = s.Name
|
||||
}
|
||||
|
||||
agentStats = append(agentStats, s)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
h.logger.Error("top-agents rows error", "error", err)
|
||||
}
|
||||
|
||||
if agentStats == nil {
|
||||
agentStats = []agentStat{}
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"span": span,
|
||||
"agents": agentStats,
|
||||
})
|
||||
}
|
||||
|
||||
// TopChannels handles GET /api/analytics/top-channels?span=24h&limit=5.
|
||||
func (h *AnalyticsHandler) TopChannels(w http.ResponseWriter, r *http.Request) {
|
||||
span := r.URL.Query().Get("span")
|
||||
if span == "" {
|
||||
span = "24h"
|
||||
}
|
||||
|
||||
cutoff, _, err := parseSpan(span)
|
||||
if err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_span", err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
limit := 5
|
||||
if l := r.URL.Query().Get("limit"); l != "" {
|
||||
if parsed, err := strconv.Atoi(l); err == nil && parsed > 0 {
|
||||
limit = parsed
|
||||
if limit > 100 {
|
||||
limit = 100
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cutoffStr := cutoff.Format("2006-01-02 15:04:05")
|
||||
|
||||
rows, err := h.db.QueryContext(r.Context(),
|
||||
`SELECT c.name, COUNT(*) as count FROM messages m JOIN channels c ON m.channel_id = c.id WHERE m.created_at >= ? AND m.channel_id IS NOT NULL GROUP BY c.name ORDER BY count DESC LIMIT ?`,
|
||||
cutoffStr, limit,
|
||||
)
|
||||
if err != nil {
|
||||
h.logger.Error("top-channels query failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to query top channels"))
|
||||
return
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type channelStat struct {
|
||||
Name string `json:"name"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
|
||||
var channelStats []channelStat
|
||||
for rows.Next() {
|
||||
var s channelStat
|
||||
if err := rows.Scan(&s.Name, &s.Count); err != nil {
|
||||
h.logger.Error("top-channels scan failed", "error", err)
|
||||
continue
|
||||
}
|
||||
channelStats = append(channelStats, s)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
h.logger.Error("top-channels rows error", "error", err)
|
||||
}
|
||||
|
||||
if channelStats == nil {
|
||||
channelStats = []channelStat{}
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"span": span,
|
||||
"channels": channelStats,
|
||||
})
|
||||
}
|
||||
|
||||
// Summary handles GET /api/analytics/summary.
|
||||
func (h *AnalyticsHandler) Summary(w http.ResponseWriter, r *http.Request) {
|
||||
var totalAgents, totalChannels, totalMessages int
|
||||
|
||||
if err := h.db.QueryRowContext(r.Context(), `SELECT COUNT(*) FROM agents WHERE status = 'active'`).Scan(&totalAgents); err != nil {
|
||||
h.logger.Error("summary agents count failed", "error", err)
|
||||
}
|
||||
|
||||
if err := h.db.QueryRowContext(r.Context(), `SELECT COUNT(*) FROM channels`).Scan(&totalChannels); err != nil {
|
||||
h.logger.Error("summary channels count failed", "error", err)
|
||||
}
|
||||
|
||||
if err := h.db.QueryRowContext(r.Context(), `SELECT COUNT(*) FROM messages`).Scan(&totalMessages); err != nil {
|
||||
h.logger.Error("summary messages count failed", "error", err)
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"total_agents": totalAgents,
|
||||
"total_channels": totalChannels,
|
||||
"total_messages": totalMessages,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,556 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
)
|
||||
|
||||
func newAnalyticsTestDB(t *testing.T) *sql.DB {
|
||||
t.Helper()
|
||||
dsn := fmt.Sprintf("file:analytics_%s?mode=memory&cache=shared", t.Name())
|
||||
db, err := sql.Open("sqlite", dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("open database: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { db.Close() })
|
||||
|
||||
if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
|
||||
t.Fatalf("enable foreign keys: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
if err := storage.RunMigrations(ctx, db); err != nil {
|
||||
t.Fatalf("run migrations: %v", err)
|
||||
}
|
||||
|
||||
// Seed test users
|
||||
db.Exec(`INSERT OR IGNORE INTO users (id, username, password_hash, display_name) VALUES (1, 'testuser', 'hash', 'Test User')`)
|
||||
|
||||
return db
|
||||
}
|
||||
|
||||
func seedAnalyticsAgent(t *testing.T, db *sql.DB, name, displayName string, ownerID int64) {
|
||||
t.Helper()
|
||||
_, err := db.Exec(
|
||||
`INSERT OR IGNORE INTO agents (name, display_name, type, capabilities, owner_id, api_key_hash, status) VALUES (?, ?, 'ai', '{}', ?, 'testhash', 'active')`,
|
||||
name, displayName, ownerID,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("seed agent %s: %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
func seedAnalyticsChannel(t *testing.T, db *sql.DB, name, createdBy string) int64 {
|
||||
t.Helper()
|
||||
result, err := db.Exec(
|
||||
`INSERT INTO channels (name, description, type, is_private, created_by, created_at, updated_at) VALUES (?, '', 'standard', 0, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`,
|
||||
name, createdBy,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("seed channel %s: %v", name, err)
|
||||
}
|
||||
id, _ := result.LastInsertId()
|
||||
return id
|
||||
}
|
||||
|
||||
func seedAnalyticsMessage(t *testing.T, db *sql.DB, from, to, body string, channelID *int64, createdAt time.Time) {
|
||||
t.Helper()
|
||||
|
||||
// Ensure a conversation exists
|
||||
result, err := db.Exec(
|
||||
`INSERT INTO conversations (subject, created_by, created_at, updated_at) VALUES ('test', ?, ?, ?)`,
|
||||
from, createdAt.Format("2006-01-02 15:04:05"), createdAt.Format("2006-01-02 15:04:05"),
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("seed conversation: %v", err)
|
||||
}
|
||||
convID, _ := result.LastInsertId()
|
||||
|
||||
_, err = db.Exec(
|
||||
`INSERT INTO messages (conversation_id, from_agent, to_agent, channel_id, body, priority, status, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, 'pending', '{}', ?, ?)`,
|
||||
convID, from, to, channelID, body, createdAt.Format("2006-01-02 15:04:05"), createdAt.Format("2006-01-02 15:04:05"),
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("seed message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func setupAnalyticsRouter(t *testing.T, db *sql.DB) chi.Router {
|
||||
t.Helper()
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, nil)
|
||||
|
||||
channelStore := channels.NewSQLiteChannelStore(db)
|
||||
msgStore := messaging.NewSQLiteMessageStore(db)
|
||||
msgService := messaging.NewMessagingService(msgStore, nil)
|
||||
channelService := channels.NewService(channelStore, msgService, nil)
|
||||
|
||||
analyticsHandler := NewAnalyticsHandler(db, agentService, channelService)
|
||||
|
||||
router := chi.NewRouter()
|
||||
router.Group(func(r chi.Router) {
|
||||
r.Use(OwnerAuthMiddleware)
|
||||
r.Get("/api/analytics/timeline", analyticsHandler.Timeline)
|
||||
r.Get("/api/analytics/top-agents", analyticsHandler.TopAgents)
|
||||
r.Get("/api/analytics/top-channels", analyticsHandler.TopChannels)
|
||||
r.Get("/api/analytics/summary", analyticsHandler.Summary)
|
||||
})
|
||||
|
||||
return router
|
||||
}
|
||||
|
||||
func analyticsRequest(t *testing.T, router chi.Router, method, path string) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
req := httptest.NewRequest(method, path, nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
return rr
|
||||
}
|
||||
|
||||
func TestAnalyticsTimeline(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
seedAnalyticsAgent(t, db, "agent-a", "Agent A", 1)
|
||||
seedAnalyticsAgent(t, db, "agent-b", "Agent B", 1)
|
||||
|
||||
now := time.Now().UTC()
|
||||
|
||||
// Seed messages at various times within the last 24h
|
||||
for i := 0; i < 5; i++ {
|
||||
seedAnalyticsMessage(t, db, "agent-a", "agent-b", fmt.Sprintf("msg-%d", i), nil, now.Add(-time.Duration(i)*time.Hour))
|
||||
}
|
||||
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
span string
|
||||
wantStatus int
|
||||
wantNonEmpty bool
|
||||
}{
|
||||
{
|
||||
name: "default span (24h)",
|
||||
span: "",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "1h span",
|
||||
span: "1h",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "4h span",
|
||||
span: "4h",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "24h span",
|
||||
span: "24h",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "7d span",
|
||||
span: "7d",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "30d span",
|
||||
span: "30d",
|
||||
wantStatus: http.StatusOK,
|
||||
wantNonEmpty: true,
|
||||
},
|
||||
{
|
||||
name: "invalid span",
|
||||
span: "99x",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
path := "/api/analytics/timeline"
|
||||
if tt.span != "" {
|
||||
path += "?span=" + tt.span
|
||||
}
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", path)
|
||||
if rr.Code != tt.wantStatus {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, tt.wantStatus, rr.Body.String())
|
||||
}
|
||||
|
||||
if tt.wantStatus != http.StatusOK {
|
||||
return
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Span string `json:"span"`
|
||||
Buckets []struct {
|
||||
Time string `json:"time"`
|
||||
Count int `json:"count"`
|
||||
} `json:"buckets"`
|
||||
Total int `json:"total"`
|
||||
}
|
||||
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
expectedSpan := tt.span
|
||||
if expectedSpan == "" {
|
||||
expectedSpan = "24h"
|
||||
}
|
||||
if resp.Span != expectedSpan {
|
||||
t.Errorf("span = %q, want %q", resp.Span, expectedSpan)
|
||||
}
|
||||
|
||||
if tt.wantNonEmpty && resp.Total == 0 {
|
||||
t.Error("expected non-zero total")
|
||||
}
|
||||
|
||||
// Verify total matches sum of bucket counts
|
||||
bucketSum := 0
|
||||
for _, b := range resp.Buckets {
|
||||
bucketSum += b.Count
|
||||
}
|
||||
if bucketSum != resp.Total {
|
||||
t.Errorf("bucket sum %d != total %d", bucketSum, resp.Total)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyticsTimeline_EmptyDB(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/timeline?span=24h")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Span string `json:"span"`
|
||||
Buckets []any `json:"buckets"`
|
||||
Total int `json:"total"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if resp.Total != 0 {
|
||||
t.Errorf("total = %d, want 0", resp.Total)
|
||||
}
|
||||
if len(resp.Buckets) != 0 {
|
||||
t.Errorf("buckets = %d, want 0", len(resp.Buckets))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyticsTopAgents(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
seedAnalyticsAgent(t, db, "agent-alpha", "Alpha Agent", 1)
|
||||
seedAnalyticsAgent(t, db, "agent-beta", "Beta Agent", 1)
|
||||
|
||||
now := time.Now().UTC()
|
||||
|
||||
// agent-alpha sends 5 messages, agent-beta sends 2
|
||||
for i := 0; i < 5; i++ {
|
||||
seedAnalyticsMessage(t, db, "agent-alpha", "agent-beta", fmt.Sprintf("msg-%d", i), nil, now.Add(-time.Duration(i)*time.Minute))
|
||||
}
|
||||
for i := 0; i < 2; i++ {
|
||||
seedAnalyticsMessage(t, db, "agent-beta", "agent-alpha", fmt.Sprintf("reply-%d", i), nil, now.Add(-time.Duration(i)*time.Minute))
|
||||
}
|
||||
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
t.Run("returns agents sorted by count", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-agents?span=24h")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Span string `json:"span"`
|
||||
Agents []struct {
|
||||
Name string `json:"name"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Count int `json:"count"`
|
||||
} `json:"agents"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Agents) < 2 {
|
||||
t.Fatalf("agents = %d, want >= 2", len(resp.Agents))
|
||||
}
|
||||
|
||||
// First agent should be alpha (5 messages)
|
||||
if resp.Agents[0].Name != "agent-alpha" {
|
||||
t.Errorf("top agent = %q, want agent-alpha", resp.Agents[0].Name)
|
||||
}
|
||||
if resp.Agents[0].Count != 5 {
|
||||
t.Errorf("top agent count = %d, want 5", resp.Agents[0].Count)
|
||||
}
|
||||
if resp.Agents[0].DisplayName != "Alpha Agent" {
|
||||
t.Errorf("display_name = %q, want 'Alpha Agent'", resp.Agents[0].DisplayName)
|
||||
}
|
||||
|
||||
// Second agent should be beta (2 messages)
|
||||
if resp.Agents[1].Name != "agent-beta" {
|
||||
t.Errorf("second agent = %q, want agent-beta", resp.Agents[1].Name)
|
||||
}
|
||||
if resp.Agents[1].Count != 2 {
|
||||
t.Errorf("second agent count = %d, want 2", resp.Agents[1].Count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("respects limit parameter", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-agents?span=24h&limit=1")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Agents []struct {
|
||||
Name string `json:"name"`
|
||||
Count int `json:"count"`
|
||||
} `json:"agents"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Agents) != 1 {
|
||||
t.Errorf("agents = %d, want 1", len(resp.Agents))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("invalid span returns error", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-agents?span=invalid")
|
||||
if rr.Code != http.StatusBadRequest {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusBadRequest)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAnalyticsTopAgents_EmptyDB(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-agents?span=24h")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Agents []any `json:"agents"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Agents) != 0 {
|
||||
t.Errorf("agents = %d, want 0", len(resp.Agents))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyticsTopChannels(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
seedAnalyticsAgent(t, db, "agent-a", "Agent A", 1)
|
||||
|
||||
chID1 := seedAnalyticsChannel(t, db, "news-mcp", "agent-a")
|
||||
chID2 := seedAnalyticsChannel(t, db, "general", "agent-a")
|
||||
|
||||
now := time.Now().UTC()
|
||||
|
||||
// news-mcp gets 4 messages, general gets 2
|
||||
for i := 0; i < 4; i++ {
|
||||
seedAnalyticsMessage(t, db, "agent-a", "", fmt.Sprintf("ch-msg-%d", i), &chID1, now.Add(-time.Duration(i)*time.Minute))
|
||||
}
|
||||
for i := 0; i < 2; i++ {
|
||||
seedAnalyticsMessage(t, db, "agent-a", "", fmt.Sprintf("gen-msg-%d", i), &chID2, now.Add(-time.Duration(i)*time.Minute))
|
||||
}
|
||||
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
t.Run("returns channels sorted by count", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-channels?span=24h")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Span string `json:"span"`
|
||||
Channels []struct {
|
||||
Name string `json:"name"`
|
||||
Count int `json:"count"`
|
||||
} `json:"channels"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Channels) < 2 {
|
||||
t.Fatalf("channels = %d, want >= 2", len(resp.Channels))
|
||||
}
|
||||
|
||||
if resp.Channels[0].Name != "news-mcp" {
|
||||
t.Errorf("top channel = %q, want news-mcp", resp.Channels[0].Name)
|
||||
}
|
||||
if resp.Channels[0].Count != 4 {
|
||||
t.Errorf("top channel count = %d, want 4", resp.Channels[0].Count)
|
||||
}
|
||||
|
||||
if resp.Channels[1].Name != "general" {
|
||||
t.Errorf("second channel = %q, want general", resp.Channels[1].Name)
|
||||
}
|
||||
if resp.Channels[1].Count != 2 {
|
||||
t.Errorf("second channel count = %d, want 2", resp.Channels[1].Count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("respects limit parameter", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-channels?span=24h&limit=1")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Channels []struct {
|
||||
Name string `json:"name"`
|
||||
Count int `json:"count"`
|
||||
} `json:"channels"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Channels) != 1 {
|
||||
t.Errorf("channels = %d, want 1", len(resp.Channels))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("invalid span returns error", func(t *testing.T) {
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-channels?span=invalid")
|
||||
if rr.Code != http.StatusBadRequest {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusBadRequest)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAnalyticsTopChannels_EmptyDB(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/top-channels?span=24h")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Channels []any `json:"channels"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Channels) != 0 {
|
||||
t.Errorf("channels = %d, want 0", len(resp.Channels))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyticsSummary(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
seedAnalyticsAgent(t, db, "agent-a", "Agent A", 1)
|
||||
seedAnalyticsAgent(t, db, "agent-b", "Agent B", 1)
|
||||
|
||||
chID := seedAnalyticsChannel(t, db, "test-channel", "agent-a")
|
||||
|
||||
now := time.Now().UTC()
|
||||
seedAnalyticsMessage(t, db, "agent-a", "agent-b", "hello", nil, now)
|
||||
seedAnalyticsMessage(t, db, "agent-b", "agent-a", "hi back", nil, now)
|
||||
seedAnalyticsMessage(t, db, "agent-a", "", "channel msg", &chID, now)
|
||||
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/summary")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
TotalAgents int `json:"total_agents"`
|
||||
TotalChannels int `json:"total_channels"`
|
||||
TotalMessages int `json:"total_messages"`
|
||||
}
|
||||
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
if resp.TotalAgents != 2 {
|
||||
t.Errorf("total_agents = %d, want 2", resp.TotalAgents)
|
||||
}
|
||||
if resp.TotalChannels != 1 {
|
||||
t.Errorf("total_channels = %d, want 1", resp.TotalChannels)
|
||||
}
|
||||
if resp.TotalMessages != 3 {
|
||||
t.Errorf("total_messages = %d, want 3", resp.TotalMessages)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyticsSummary_EmptyDB(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
rr := analyticsRequest(t, router, "GET", "/api/analytics/summary")
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
TotalAgents int `json:"total_agents"`
|
||||
TotalChannels int `json:"total_channels"`
|
||||
TotalMessages int `json:"total_messages"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if resp.TotalAgents != 0 {
|
||||
t.Errorf("total_agents = %d, want 0", resp.TotalAgents)
|
||||
}
|
||||
if resp.TotalChannels != 0 {
|
||||
t.Errorf("total_channels = %d, want 0", resp.TotalChannels)
|
||||
}
|
||||
if resp.TotalMessages != 0 {
|
||||
t.Errorf("total_messages = %d, want 0", resp.TotalMessages)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalytics_Unauthenticated(t *testing.T) {
|
||||
db := newAnalyticsTestDB(t)
|
||||
router := setupAnalyticsRouter(t, db)
|
||||
|
||||
endpoints := []string{
|
||||
"/api/analytics/timeline",
|
||||
"/api/analytics/top-agents",
|
||||
"/api/analytics/top-channels",
|
||||
"/api/analytics/summary",
|
||||
}
|
||||
|
||||
for _, endpoint := range endpoints {
|
||||
t.Run(endpoint, func(t *testing.T) {
|
||||
req := httptest.NewRequest("GET", endpoint, nil)
|
||||
// No X-Owner-ID header
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusUnauthorized {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusUnauthorized)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
)
|
||||
|
||||
// NewMessageEvent is broadcast when a new message is sent.
|
||||
type NewMessageEvent struct {
|
||||
Channel string `json:"channel,omitempty"` // set for channel messages
|
||||
FromAgent string `json:"from_agent,omitempty"` // set for DMs
|
||||
ToAgent string `json:"to_agent,omitempty"` // set for DMs
|
||||
MessageID int64 `json:"message_id"`
|
||||
}
|
||||
|
||||
// UnreadUpdateEvent is broadcast when unread counts change (e.g. mark-read).
|
||||
type UnreadUpdateEvent struct {
|
||||
Channel string `json:"channel,omitempty"`
|
||||
Agent string `json:"agent,omitempty"`
|
||||
UnreadCount int `json:"unread_count"`
|
||||
}
|
||||
|
||||
// EventBroadcaster broadcasts real-time events to connected SSE clients.
|
||||
type EventBroadcaster interface {
|
||||
BroadcastNewMessage(ctx context.Context, ownerID int64, event NewMessageEvent)
|
||||
BroadcastUnreadUpdate(ctx context.Context, ownerID int64, event UnreadUpdateEvent)
|
||||
}
|
||||
|
||||
// SSEBroadcaster implements EventBroadcaster using the SSEHub.
|
||||
type SSEBroadcaster struct {
|
||||
hub *SSEHub
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewSSEBroadcaster creates a broadcaster that sends events via SSE.
|
||||
func NewSSEBroadcaster(hub *SSEHub, agentService *agents.AgentService, channelService *channels.Service) *SSEBroadcaster {
|
||||
return &SSEBroadcaster{
|
||||
hub: hub,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
logger: slog.Default().With("component", "api.broadcaster"),
|
||||
}
|
||||
}
|
||||
|
||||
// BroadcastNewMessage sends a new_message event to the given owner.
|
||||
func (b *SSEBroadcaster) BroadcastNewMessage(_ context.Context, ownerID int64, event NewMessageEvent) {
|
||||
b.hub.Broadcast(ownerID, SSEEvent{
|
||||
Type: "new_message",
|
||||
Data: event,
|
||||
})
|
||||
}
|
||||
|
||||
// BroadcastUnreadUpdate sends an unread_update event to the given owner.
|
||||
func (b *SSEBroadcaster) BroadcastUnreadUpdate(_ context.Context, ownerID int64, event UnreadUpdateEvent) {
|
||||
b.hub.Broadcast(ownerID, SSEEvent{
|
||||
Type: "unread_update",
|
||||
Data: event,
|
||||
})
|
||||
}
|
||||
|
||||
// BroadcastDM broadcasts a new_message event for a direct message.
|
||||
// It resolves the recipient agent's owner and sends the event to them.
|
||||
func (b *SSEBroadcaster) BroadcastDM(ctx context.Context, msg NewMessageEvent) {
|
||||
if msg.ToAgent == "" {
|
||||
return
|
||||
}
|
||||
|
||||
agent, err := b.agentService.GetAgent(ctx, msg.ToAgent)
|
||||
if err != nil {
|
||||
b.logger.Debug("could not resolve recipient owner for SSE broadcast",
|
||||
"to_agent", msg.ToAgent, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
b.BroadcastNewMessage(ctx, agent.OwnerID, msg)
|
||||
}
|
||||
|
||||
// BroadcastChannelMessage broadcasts a new_message event for a channel message.
|
||||
// It resolves all channel members' owners and sends the event to each unique owner.
|
||||
func (b *SSEBroadcaster) BroadcastChannelMessage(ctx context.Context, channelID int64, msg NewMessageEvent) {
|
||||
if b.channelService == nil {
|
||||
return
|
||||
}
|
||||
|
||||
members, err := b.channelService.GetMembers(ctx, channelID)
|
||||
if err != nil {
|
||||
b.logger.Debug("could not get channel members for SSE broadcast",
|
||||
"channel_id", channelID, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Collect unique owner IDs to avoid duplicate broadcasts.
|
||||
seen := make(map[int64]bool)
|
||||
for _, m := range members {
|
||||
agent, err := b.agentService.GetAgent(ctx, m.AgentName)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if !seen[agent.OwnerID] {
|
||||
seen[agent.OwnerID] = true
|
||||
b.BroadcastNewMessage(ctx, agent.OwnerID, msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// OnMessageSent implements messaging.MessageListener so the SSEBroadcaster
|
||||
// can be wired directly into the messaging service. This ensures SSE events
|
||||
// fire for messages sent via MCP (agents) as well as the REST API.
|
||||
func (b *SSEBroadcaster) OnMessageSent(ctx context.Context, msg *messaging.Message) {
|
||||
event := NewMessageEvent{
|
||||
MessageID: msg.ID,
|
||||
FromAgent: msg.FromAgent,
|
||||
ToAgent: msg.ToAgent,
|
||||
}
|
||||
|
||||
if msg.ChannelID != nil {
|
||||
ch, err := b.channelService.GetChannel(ctx, *msg.ChannelID)
|
||||
if err == nil {
|
||||
event.Channel = ch.Name
|
||||
}
|
||||
b.BroadcastChannelMessage(ctx, *msg.ChannelID, event)
|
||||
} else {
|
||||
b.BroadcastDM(ctx, event)
|
||||
}
|
||||
}
|
||||
@@ -201,7 +201,7 @@ func (h *ChannelsHandler) JoinChannel(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
// ChannelMessages handles GET /api/channels/{name}/messages.
|
||||
func (h *ChannelsHandler) ChannelMessages(w http.ResponseWriter, r *http.Request) {
|
||||
_, ok := OwnerIDFromContext(r.Context())
|
||||
ownerID, ok := OwnerIDFromContext(r.Context())
|
||||
if !ok {
|
||||
writeJSON(w, http.StatusUnauthorized, errorBody("unauthorized", "Authentication required"))
|
||||
return
|
||||
@@ -221,16 +221,29 @@ func (h *ChannelsHandler) ChannelMessages(w http.ResponseWriter, r *http.Request
|
||||
}
|
||||
}
|
||||
|
||||
msgs, err := h.msgService.GetChannelMessages(r.Context(), ch.ID, limit)
|
||||
paginated, err := h.msgService.GetChannelMessages(r.Context(), ch.ID, limit, 0)
|
||||
if err != nil {
|
||||
h.logger.Error("get channel messages failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to get messages"))
|
||||
return
|
||||
}
|
||||
|
||||
// Compute last_read_message_id across owned agents
|
||||
var lastReadMessageID int64
|
||||
ownedAgents, err := h.agentService.ListAgents(r.Context(), ownerID)
|
||||
if err == nil {
|
||||
for _, agent := range ownedAgents {
|
||||
lr, err := h.msgService.GetLastReadForChannel(r.Context(), agent.Name, ch.ID)
|
||||
if err == nil && lr > lastReadMessageID {
|
||||
lastReadMessageID = lr
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"messages": msgs,
|
||||
"total": len(msgs),
|
||||
"messages": paginated.Messages,
|
||||
"total": paginated.Total,
|
||||
"last_read_message_id": lastReadMessageID,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
@@ -18,9 +19,15 @@ import (
|
||||
type MessagesHandler struct {
|
||||
msgService *messaging.MessagingService
|
||||
agentService *agents.AgentService
|
||||
broadcaster *SSEBroadcaster
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// SetBroadcaster sets the event broadcaster for real-time SSE notifications.
|
||||
func (h *MessagesHandler) SetBroadcaster(b *SSEBroadcaster) {
|
||||
h.broadcaster = b
|
||||
}
|
||||
|
||||
// NewMessagesHandler creates a new messages handler.
|
||||
func NewMessagesHandler(msgService *messaging.MessagingService, agentService *agents.AgentService) *MessagesHandler {
|
||||
return &MessagesHandler{
|
||||
@@ -67,12 +74,12 @@ func (h *MessagesHandler) ListMessages(w http.ResponseWriter, r *http.Request) {
|
||||
IncludeRead: true,
|
||||
Status: status,
|
||||
}
|
||||
msgs, err := h.msgService.ReadInbox(r.Context(), agent.Name, opts)
|
||||
result, err := h.msgService.ReadInbox(r.Context(), agent.Name, opts)
|
||||
if err != nil {
|
||||
h.logger.Error("read inbox failed", "agent", agent.Name, "error", err)
|
||||
continue
|
||||
}
|
||||
allMessages = append(allMessages, msgs...)
|
||||
allMessages = append(allMessages, result.Messages...)
|
||||
}
|
||||
|
||||
if allMessages == nil {
|
||||
@@ -153,11 +160,11 @@ func (h *MessagesHandler) ListConversations(w http.ResponseWriter, r *http.Reque
|
||||
Limit: 100,
|
||||
IncludeRead: true,
|
||||
}
|
||||
msgs, err := h.msgService.ReadInbox(r.Context(), agent.Name, opts)
|
||||
result, err := h.msgService.ReadInbox(r.Context(), agent.Name, opts)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
for _, msg := range msgs {
|
||||
for _, msg := range result.Messages {
|
||||
existing, exists := convMap[msg.ConversationID]
|
||||
if !exists {
|
||||
convMap[msg.ConversationID] = &convSummary{
|
||||
@@ -309,6 +316,9 @@ func (h *MessagesHandler) SendMessage(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
// SSE broadcast is handled by the MessageListener on the messaging
|
||||
// service, so it fires for both REST and MCP message paths.
|
||||
|
||||
writeJSON(w, http.StatusCreated, msg)
|
||||
}
|
||||
|
||||
@@ -390,14 +400,65 @@ func (h *MessagesHandler) SearchMessages(w http.ResponseWriter, r *http.Request)
|
||||
limit = 20
|
||||
}
|
||||
|
||||
// Parse advanced filter parameters
|
||||
channelFilter := r.URL.Query().Get("channel")
|
||||
agentFilter := r.URL.Query().Get("agent")
|
||||
afterFilter := r.URL.Query().Get("after")
|
||||
beforeFilter := r.URL.Query().Get("before")
|
||||
|
||||
var allMessages []*messaging.Message
|
||||
for _, agent := range ownedAgents {
|
||||
opts := messaging.SearchOptions{Limit: limit}
|
||||
msgs, err := h.msgService.SearchMessages(r.Context(), agent.Name, query, opts)
|
||||
opts := messaging.SearchOptions{
|
||||
Limit: limit,
|
||||
After: afterFilter,
|
||||
Before: beforeFilter,
|
||||
}
|
||||
|
||||
// Apply channel filters (comma-separated, prefix with - to exclude)
|
||||
if channelFilter != "" {
|
||||
channels := strings.Split(channelFilter, ",")
|
||||
var includeChannels []string
|
||||
var excludeChannels []string
|
||||
for _, ch := range channels {
|
||||
ch = strings.TrimSpace(ch)
|
||||
if ch == "" {
|
||||
continue
|
||||
}
|
||||
if strings.HasPrefix(ch, "-") {
|
||||
excludeChannels = append(excludeChannels, strings.TrimPrefix(ch, "-"))
|
||||
} else {
|
||||
includeChannels = append(includeChannels, ch)
|
||||
}
|
||||
}
|
||||
opts.Channels = includeChannels
|
||||
opts.ExcludeChannels = excludeChannels
|
||||
}
|
||||
|
||||
// Apply agent filters (comma-separated, prefix with - to exclude)
|
||||
if agentFilter != "" {
|
||||
agentNames := strings.Split(agentFilter, ",")
|
||||
var includeAgents []string
|
||||
var excludeAgents []string
|
||||
for _, a := range agentNames {
|
||||
a = strings.TrimSpace(a)
|
||||
if a == "" {
|
||||
continue
|
||||
}
|
||||
if strings.HasPrefix(a, "-") {
|
||||
excludeAgents = append(excludeAgents, strings.TrimPrefix(a, "-"))
|
||||
} else {
|
||||
includeAgents = append(includeAgents, a)
|
||||
}
|
||||
}
|
||||
opts.Agents = includeAgents
|
||||
opts.ExcludeAgents = excludeAgents
|
||||
}
|
||||
|
||||
result, err := h.msgService.SearchMessages(r.Context(), agent.Name, query, opts)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
allMessages = append(allMessages, msgs...)
|
||||
allMessages = append(allMessages, result.Messages...)
|
||||
}
|
||||
|
||||
if allMessages == nil {
|
||||
@@ -489,9 +550,13 @@ func (h *MessagesHandler) DMMessages(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
// Include last_read_message_id for the human agent's DM with the peer
|
||||
lastRead, _ := h.msgService.GetLastReadForDM(r.Context(), agentNames, peerAgent)
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"messages": msgs,
|
||||
"total": len(msgs),
|
||||
"messages": msgs,
|
||||
"total": len(msgs),
|
||||
"last_read_message_id": lastRead,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
)
|
||||
|
||||
// NotificationsHandler handles REST API requests for notification badges.
|
||||
type NotificationsHandler struct {
|
||||
msgService *messaging.MessagingService
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewNotificationsHandler creates a new notifications handler.
|
||||
func NewNotificationsHandler(msgService *messaging.MessagingService, agentService *agents.AgentService, channelService *channels.Service) *NotificationsHandler {
|
||||
return &NotificationsHandler{
|
||||
msgService: msgService,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
logger: slog.Default().With("component", "api.notifications"),
|
||||
}
|
||||
}
|
||||
|
||||
// channelUnread is the JSON shape for a channel's unread info.
|
||||
type channelUnread struct {
|
||||
Name string `json:"name"`
|
||||
UnreadCount int `json:"unread_count"`
|
||||
LastMessageID int64 `json:"last_message_id"`
|
||||
}
|
||||
|
||||
// dmUnread is the JSON shape for a DM peer's unread info.
|
||||
type dmUnread struct {
|
||||
Agent string `json:"agent"`
|
||||
UnreadCount int `json:"unread_count"`
|
||||
LastMessageID int64 `json:"last_message_id"`
|
||||
}
|
||||
|
||||
// UnreadCounts handles GET /api/notifications/unread.
|
||||
func (h *NotificationsHandler) UnreadCounts(w http.ResponseWriter, r *http.Request) {
|
||||
ownerID, ok := OwnerIDFromContext(r.Context())
|
||||
if !ok {
|
||||
writeJSON(w, http.StatusUnauthorized, errorBody("unauthorized", "Authentication required"))
|
||||
return
|
||||
}
|
||||
|
||||
// Use only the human agent's perspective for notification counts.
|
||||
// This avoids system/AI agents inflating unread counts.
|
||||
humanAgent, err := h.agentService.GetHumanAgentForUser(r.Context(), ownerID)
|
||||
if err != nil || humanAgent == nil {
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"channels": []channelUnread{},
|
||||
"dms": []dmUnread{},
|
||||
"total_unread": 0,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// Channel summaries for the human agent
|
||||
channelsList := []channelUnread{}
|
||||
if h.channelService != nil {
|
||||
summaries, err := h.channelService.GetChannelSummaries(r.Context(), humanAgent.Name)
|
||||
if err != nil {
|
||||
h.logger.Error("get channel summaries failed", "agent", humanAgent.Name, "error", err)
|
||||
} else {
|
||||
for _, cs := range summaries {
|
||||
channelsList = append(channelsList, channelUnread{
|
||||
Name: cs.Name,
|
||||
UnreadCount: cs.UnreadCount,
|
||||
LastMessageID: cs.LastMessageID,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// DM unread counts for the human agent
|
||||
dmMap := make(map[string]*dmUnread)
|
||||
counts, err := h.msgService.GetDMUnreadCounts(r.Context(), humanAgent.Name)
|
||||
if err != nil {
|
||||
h.logger.Error("get dm unread counts failed", "agent", humanAgent.Name, "error", err)
|
||||
} else {
|
||||
for _, dc := range counts {
|
||||
dmMap[dc.Agent] = &dmUnread{
|
||||
Agent: dc.Agent,
|
||||
UnreadCount: dc.UnreadCount,
|
||||
LastMessageID: dc.LastMessageID,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dmsList := make([]dmUnread, 0, len(dmMap))
|
||||
for _, du := range dmMap {
|
||||
dmsList = append(dmsList, *du)
|
||||
}
|
||||
|
||||
totalUnread := 0
|
||||
for _, cu := range channelsList {
|
||||
totalUnread += cu.UnreadCount
|
||||
}
|
||||
for _, du := range dmsList {
|
||||
totalUnread += du.UnreadCount
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"channels": channelsList,
|
||||
"dms": dmsList,
|
||||
"total_unread": totalUnread,
|
||||
})
|
||||
}
|
||||
|
||||
// MarkRead handles POST /api/notifications/mark-read.
|
||||
func (h *NotificationsHandler) MarkRead(w http.ResponseWriter, r *http.Request) {
|
||||
ownerID, ok := OwnerIDFromContext(r.Context())
|
||||
if !ok {
|
||||
writeJSON(w, http.StatusUnauthorized, errorBody("unauthorized", "Authentication required"))
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
Type string `json:"type"`
|
||||
Target string `json:"target"`
|
||||
LastMessageID int64 `json:"last_message_id"`
|
||||
}
|
||||
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_request", "Invalid JSON body"))
|
||||
return
|
||||
}
|
||||
|
||||
if req.Type == "" || req.Target == "" || req.LastMessageID <= 0 {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("validation_error", "type, target, and last_message_id are required"))
|
||||
return
|
||||
}
|
||||
|
||||
if req.Type != "channel" && req.Type != "dm" {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("validation_error", "type must be 'channel' or 'dm'"))
|
||||
return
|
||||
}
|
||||
|
||||
humanAgent, err := h.agentService.GetHumanAgentForUser(r.Context(), ownerID)
|
||||
if err != nil || humanAgent == nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("no_agents", "No human agent found"))
|
||||
return
|
||||
}
|
||||
|
||||
agentNames := []string{humanAgent.Name}
|
||||
|
||||
if req.Type == "channel" {
|
||||
if h.channelService == nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("not_available", "Channel service not available"))
|
||||
return
|
||||
}
|
||||
|
||||
ch, err := h.channelService.GetChannelByName(r.Context(), req.Target)
|
||||
if err != nil {
|
||||
writeJSON(w, http.StatusNotFound, errorBody("not_found", "Channel not found"))
|
||||
return
|
||||
}
|
||||
|
||||
convIDs, err := h.msgService.GetConversationIDsForChannel(r.Context(), ch.ID, req.LastMessageID)
|
||||
if err != nil {
|
||||
h.logger.Error("get conversation ids failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to get conversations"))
|
||||
return
|
||||
}
|
||||
|
||||
for _, convID := range convIDs {
|
||||
if err := h.msgService.UpdateInboxState(r.Context(), humanAgent.Name, convID, req.LastMessageID); err != nil {
|
||||
h.logger.Error("update inbox state failed",
|
||||
"agent", humanAgent.Name,
|
||||
"conversation_id", convID,
|
||||
"error", err,
|
||||
)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// DM mark-read
|
||||
convIDs, err := h.msgService.GetConversationIDsForDM(r.Context(), agentNames, req.Target, req.LastMessageID)
|
||||
if err != nil {
|
||||
h.logger.Error("get dm conversation ids failed", "error", err)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to get conversations"))
|
||||
return
|
||||
}
|
||||
|
||||
for _, convID := range convIDs {
|
||||
if err := h.msgService.UpdateInboxState(r.Context(), humanAgent.Name, convID, req.LastMessageID); err != nil {
|
||||
h.logger.Error("update inbox state failed",
|
||||
"agent", humanAgent.Name,
|
||||
"conversation_id", convID,
|
||||
"error", err,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
@@ -0,0 +1,373 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
)
|
||||
|
||||
func setupNotificationsRouter(t *testing.T) (chi.Router, *messaging.MessagingService, *agents.AgentService, *channels.Service) {
|
||||
t.Helper()
|
||||
db := newTestDBFull(t)
|
||||
|
||||
msgStore := messaging.NewSQLiteMessageStore(db)
|
||||
msgService := messaging.NewMessagingService(msgStore, nil)
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, nil)
|
||||
|
||||
channelStore := channels.NewSQLiteChannelStore(db)
|
||||
channelService := channels.NewService(channelStore, msgService, nil)
|
||||
|
||||
// Seed agents — human-agent must be type 'human' for GetHumanAgentForUser
|
||||
seedTestAgentWithType(t, db, "human-agent", "human", 1)
|
||||
seedTestAgent(t, db, "bot-alice", 2)
|
||||
seedTestAgent(t, db, "bot-bob", 2)
|
||||
|
||||
handler := NewNotificationsHandler(msgService, agentService, channelService)
|
||||
messagesHandler := NewMessagesHandler(msgService, agentService)
|
||||
channelsHandler := NewChannelsHandler(channelService, agentService, msgService)
|
||||
|
||||
router := chi.NewRouter()
|
||||
router.Group(func(r chi.Router) {
|
||||
r.Use(OwnerAuthMiddleware)
|
||||
r.Get("/api/notifications/unread", handler.UnreadCounts)
|
||||
r.Post("/api/notifications/mark-read", handler.MarkRead)
|
||||
r.Get("/api/channels/{name}/messages", channelsHandler.ChannelMessages)
|
||||
r.Get("/api/agents/{name}/messages", messagesHandler.DMMessages)
|
||||
})
|
||||
|
||||
return router, msgService, agentService, channelService
|
||||
}
|
||||
|
||||
func TestUnreadCounts_Unauthenticated(t *testing.T) {
|
||||
router, _, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/notifications/unread", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusUnauthorized {
|
||||
t.Errorf("status = %d, want %d", rr.Code, http.StatusUnauthorized)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnreadCounts_NoAgents(t *testing.T) {
|
||||
router, _, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
// Owner 99 has no agents
|
||||
req := httptest.NewRequest("GET", "/api/notifications/unread", nil)
|
||||
req.Header.Set("X-Owner-ID", "99")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Channels []channelUnread `json:"channels"`
|
||||
DMs []dmUnread `json:"dms"`
|
||||
TotalUnread int `json:"total_unread"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.Channels) != 0 {
|
||||
t.Errorf("channels = %d, want 0", len(resp.Channels))
|
||||
}
|
||||
if len(resp.DMs) != 0 {
|
||||
t.Errorf("dms = %d, want 0", len(resp.DMs))
|
||||
}
|
||||
if resp.TotalUnread != 0 {
|
||||
t.Errorf("total_unread = %d, want 0", resp.TotalUnread)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnreadCounts_WithDMs(t *testing.T) {
|
||||
router, msgService, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
ctx := t.Context()
|
||||
|
||||
// bot-alice sends DMs to human-agent (owner 1)
|
||||
_, err := msgService.SendMessage(ctx, "bot-alice", "human-agent", "Hello from Alice", messaging.SendOptions{Subject: "dm"})
|
||||
if err != nil {
|
||||
t.Fatalf("send message: %v", err)
|
||||
}
|
||||
_, err = msgService.SendMessage(ctx, "bot-alice", "human-agent", "Second message from Alice", messaging.SendOptions{Subject: "dm"})
|
||||
if err != nil {
|
||||
t.Fatalf("send message: %v", err)
|
||||
}
|
||||
|
||||
// bot-bob sends a DM to human-agent
|
||||
_, err = msgService.SendMessage(ctx, "bot-bob", "human-agent", "Hello from Bob", messaging.SendOptions{Subject: "dm"})
|
||||
if err != nil {
|
||||
t.Fatalf("send message: %v", err)
|
||||
}
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/notifications/unread", nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Channels []channelUnread `json:"channels"`
|
||||
DMs []dmUnread `json:"dms"`
|
||||
TotalUnread int `json:"total_unread"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.DMs) != 2 {
|
||||
t.Fatalf("dms = %d, want 2; body: %s", len(resp.DMs), rr.Body.String())
|
||||
}
|
||||
|
||||
// Find alice and bob counts
|
||||
dmsByAgent := make(map[string]dmUnread)
|
||||
for _, dm := range resp.DMs {
|
||||
dmsByAgent[dm.Agent] = dm
|
||||
}
|
||||
|
||||
if alice, ok := dmsByAgent["bot-alice"]; !ok {
|
||||
t.Error("expected DM from bot-alice")
|
||||
} else if alice.UnreadCount != 2 {
|
||||
t.Errorf("bot-alice unread = %d, want 2", alice.UnreadCount)
|
||||
}
|
||||
|
||||
if bob, ok := dmsByAgent["bot-bob"]; !ok {
|
||||
t.Error("expected DM from bot-bob")
|
||||
} else if bob.UnreadCount != 1 {
|
||||
t.Errorf("bot-bob unread = %d, want 1", bob.UnreadCount)
|
||||
}
|
||||
|
||||
if resp.TotalUnread != 3 {
|
||||
t.Errorf("total_unread = %d, want 3", resp.TotalUnread)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarkRead_DM(t *testing.T) {
|
||||
router, msgService, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
ctx := t.Context()
|
||||
|
||||
// bot-alice sends 3 DMs to human-agent
|
||||
msg1, _ := msgService.SendMessage(ctx, "bot-alice", "human-agent", "Message 1", messaging.SendOptions{Subject: "dm"})
|
||||
_, _ = msgService.SendMessage(ctx, "bot-alice", "human-agent", "Message 2", messaging.SendOptions{Subject: "dm"})
|
||||
msg3, _ := msgService.SendMessage(ctx, "bot-alice", "human-agent", "Message 3", messaging.SendOptions{Subject: "dm"})
|
||||
|
||||
// Mark read up to msg1
|
||||
body, _ := json.Marshal(map[string]any{
|
||||
"type": "dm",
|
||||
"target": "bot-alice",
|
||||
"last_message_id": msg1.ID,
|
||||
})
|
||||
req := httptest.NewRequest("POST", "/api/notifications/mark-read", bytes.NewReader(body))
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("mark-read status = %d, want %d, body: %s", rr.Code, http.StatusOK, rr.Body.String())
|
||||
}
|
||||
|
||||
// Check unread — should have 2 unread still
|
||||
req = httptest.NewRequest("GET", "/api/notifications/unread", nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr = httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
var resp struct {
|
||||
DMs []dmUnread `json:"dms"`
|
||||
TotalUnread int `json:"total_unread"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if len(resp.DMs) != 1 {
|
||||
t.Fatalf("dms = %d, want 1; body: %s", len(resp.DMs), rr.Body.String())
|
||||
}
|
||||
if resp.DMs[0].UnreadCount != 2 {
|
||||
t.Errorf("unread after mark-read = %d, want 2", resp.DMs[0].UnreadCount)
|
||||
}
|
||||
|
||||
// Mark all read up to msg3
|
||||
body, _ = json.Marshal(map[string]any{
|
||||
"type": "dm",
|
||||
"target": "bot-alice",
|
||||
"last_message_id": msg3.ID,
|
||||
})
|
||||
req = httptest.NewRequest("POST", "/api/notifications/mark-read", bytes.NewReader(body))
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr = httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("mark-read status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
// Check unread — should be 0
|
||||
req = httptest.NewRequest("GET", "/api/notifications/unread", nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr = httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
if resp.TotalUnread != 0 {
|
||||
t.Errorf("total_unread after marking all read = %d, want 0; body: %s", resp.TotalUnread, rr.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarkRead_Validation(t *testing.T) {
|
||||
router, _, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
body map[string]any
|
||||
want int
|
||||
}{
|
||||
{
|
||||
name: "missing type",
|
||||
body: map[string]any{"target": "foo", "last_message_id": 1},
|
||||
want: http.StatusBadRequest,
|
||||
},
|
||||
{
|
||||
name: "missing target",
|
||||
body: map[string]any{"type": "dm", "last_message_id": 1},
|
||||
want: http.StatusBadRequest,
|
||||
},
|
||||
{
|
||||
name: "missing last_message_id",
|
||||
body: map[string]any{"type": "dm", "target": "foo"},
|
||||
want: http.StatusBadRequest,
|
||||
},
|
||||
{
|
||||
name: "invalid type",
|
||||
body: map[string]any{"type": "invalid", "target": "foo", "last_message_id": 1},
|
||||
want: http.StatusBadRequest,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
body, _ := json.Marshal(tt.body)
|
||||
req := httptest.NewRequest("POST", "/api/notifications/mark-read", bytes.NewReader(body))
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != tt.want {
|
||||
t.Errorf("status = %d, want %d, body: %s", rr.Code, tt.want, rr.Body.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDMMessages_IncludesLastRead(t *testing.T) {
|
||||
router, msgService, _, _ := setupNotificationsRouter(t)
|
||||
|
||||
ctx := t.Context()
|
||||
|
||||
// Send DMs from bot-alice to human-agent
|
||||
msg1, _ := msgService.SendMessage(ctx, "bot-alice", "human-agent", "Hello", messaging.SendOptions{Subject: "dm"})
|
||||
_, _ = msgService.SendMessage(ctx, "bot-alice", "human-agent", "World", messaging.SendOptions{Subject: "dm"})
|
||||
|
||||
// Mark read up to msg1
|
||||
body, _ := json.Marshal(map[string]any{
|
||||
"type": "dm",
|
||||
"target": "bot-alice",
|
||||
"last_message_id": msg1.ID,
|
||||
})
|
||||
req := httptest.NewRequest("POST", "/api/notifications/mark-read", bytes.NewReader(body))
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("mark-read status = %d", rr.Code)
|
||||
}
|
||||
|
||||
// GET DM messages should include last_read_message_id
|
||||
req = httptest.NewRequest("GET", "/api/agents/bot-alice/messages", nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr = httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("dm messages status = %d, body: %s", rr.Code, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
lastRead, ok := resp["last_read_message_id"]
|
||||
if !ok {
|
||||
t.Fatal("response missing last_read_message_id")
|
||||
}
|
||||
if int64(lastRead.(float64)) != msg1.ID {
|
||||
t.Errorf("last_read_message_id = %v, want %d", lastRead, msg1.ID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelMessages_IncludesLastRead(t *testing.T) {
|
||||
router, _, _, channelService := setupNotificationsRouter(t)
|
||||
|
||||
ctx := t.Context()
|
||||
|
||||
// Create a channel and have human-agent join
|
||||
ch, err := channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "test-channel",
|
||||
CreatedBy: "human-agent",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("create channel: %v", err)
|
||||
}
|
||||
|
||||
// Broadcast messages
|
||||
msgs, err := channelService.BroadcastMessage(ctx, ch.ID, "human-agent", "Hello channel", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("broadcast: %v", err)
|
||||
}
|
||||
|
||||
// Mark read up to the first channel message
|
||||
body, _ := json.Marshal(map[string]any{
|
||||
"type": "channel",
|
||||
"target": "test-channel",
|
||||
"last_message_id": msgs[0].ID,
|
||||
})
|
||||
req := httptest.NewRequest("POST", "/api/notifications/mark-read", bytes.NewReader(body))
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr := httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("mark-read status = %d, body: %s", rr.Code, rr.Body.String())
|
||||
}
|
||||
|
||||
// GET channel messages should include last_read_message_id
|
||||
req = httptest.NewRequest("GET", "/api/channels/test-channel/messages", nil)
|
||||
req.Header.Set("X-Owner-ID", "1")
|
||||
rr = httptest.NewRecorder()
|
||||
router.ServeHTTP(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("channel messages status = %d, body: %s", rr.Code, rr.Body.String())
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
_, ok := resp["last_read_message_id"]
|
||||
if !ok {
|
||||
t.Fatal("response missing last_read_message_id")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/push"
|
||||
)
|
||||
|
||||
// PushHandler manages Web Push notification subscription endpoints.
|
||||
type PushHandler struct {
|
||||
pushService *push.Service
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewPushHandler creates a new push notification handler.
|
||||
func NewPushHandler(pushService *push.Service) *PushHandler {
|
||||
return &PushHandler{
|
||||
pushService: pushService,
|
||||
logger: slog.Default().With("component", "api.push"),
|
||||
}
|
||||
}
|
||||
|
||||
// subscribeRequest is the JSON body for POST /api/push/subscribe.
|
||||
type subscribeRequest struct {
|
||||
Endpoint string `json:"endpoint"`
|
||||
KeyP256dh string `json:"key_p256dh"`
|
||||
KeyAuth string `json:"key_auth"`
|
||||
}
|
||||
|
||||
// unsubscribeRequest is the JSON body for DELETE /api/push/subscribe.
|
||||
type unsubscribeRequest struct {
|
||||
Endpoint string `json:"endpoint"`
|
||||
}
|
||||
|
||||
// Subscribe handles POST /api/push/subscribe.
|
||||
// Registers a Web Push subscription for the authenticated user.
|
||||
func (h *PushHandler) Subscribe(w http.ResponseWriter, r *http.Request) {
|
||||
ownerID, ok := OwnerIDFromContext(r.Context())
|
||||
if !ok {
|
||||
writeJSON(w, http.StatusUnauthorized, errorBody("unauthorized", "Authentication required"))
|
||||
return
|
||||
}
|
||||
|
||||
var req subscribeRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_request", "Invalid JSON body"))
|
||||
return
|
||||
}
|
||||
|
||||
if req.Endpoint == "" || req.KeyP256dh == "" || req.KeyAuth == "" {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("validation_error", "endpoint, key_p256dh, and key_auth are required"))
|
||||
return
|
||||
}
|
||||
|
||||
userAgent := r.Header.Get("User-Agent")
|
||||
|
||||
if err := h.pushService.Subscribe(r.Context(), ownerID, req.Endpoint, req.KeyP256dh, req.KeyAuth, userAgent); err != nil {
|
||||
h.logger.Error("push subscribe failed",
|
||||
"user_id", ownerID,
|
||||
"error", err,
|
||||
)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to register subscription"))
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Info("push subscription registered",
|
||||
"user_id", ownerID,
|
||||
)
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "subscribed"})
|
||||
}
|
||||
|
||||
// Unsubscribe handles DELETE /api/push/subscribe.
|
||||
// Removes a Web Push subscription for the authenticated user.
|
||||
func (h *PushHandler) Unsubscribe(w http.ResponseWriter, r *http.Request) {
|
||||
ownerID, ok := OwnerIDFromContext(r.Context())
|
||||
if !ok {
|
||||
writeJSON(w, http.StatusUnauthorized, errorBody("unauthorized", "Authentication required"))
|
||||
return
|
||||
}
|
||||
|
||||
var req unsubscribeRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("invalid_request", "Invalid JSON body"))
|
||||
return
|
||||
}
|
||||
|
||||
if req.Endpoint == "" {
|
||||
writeJSON(w, http.StatusBadRequest, errorBody("validation_error", "endpoint is required"))
|
||||
return
|
||||
}
|
||||
|
||||
if err := h.pushService.Unsubscribe(r.Context(), ownerID, req.Endpoint); err != nil {
|
||||
h.logger.Error("push unsubscribe failed",
|
||||
"error", err,
|
||||
)
|
||||
writeJSON(w, http.StatusInternalServerError, errorBody("server_error", "Failed to remove subscription"))
|
||||
return
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "unsubscribed"})
|
||||
}
|
||||
|
||||
// VAPIDKey handles GET /api/push/vapid-key.
|
||||
// Returns the VAPID public key needed by clients to subscribe to push notifications.
|
||||
func (h *PushHandler) VAPIDKey(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{
|
||||
"vapid_public_key": h.pushService.GetVAPIDPublicKey(),
|
||||
})
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
@@ -11,6 +12,7 @@ import (
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/k8s"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/push"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
"github.com/synapbus/synapbus/internal/webhooks"
|
||||
)
|
||||
@@ -30,8 +32,12 @@ type RouterConfig struct {
|
||||
WebhookStore webhooks.WebhookStore
|
||||
K8sService *k8s.K8sService
|
||||
K8sStore k8s.K8sStore
|
||||
PushService *push.Service
|
||||
SSEHub *SSEHub
|
||||
Broadcaster *SSEBroadcaster
|
||||
SessionMiddleware func(http.Handler) http.Handler
|
||||
DB *sql.DB
|
||||
Version string
|
||||
}
|
||||
|
||||
// NewRouter creates a chi router with all API routes configured.
|
||||
@@ -85,6 +91,14 @@ func NewRouterWithConfig(cfg RouterConfig) chi.Router {
|
||||
if cfg.MsgService != nil && cfg.AgentService != nil {
|
||||
messagesHandler := NewMessagesHandler(cfg.MsgService, cfg.AgentService)
|
||||
agentsHandler := NewAgentsHandler(cfg.AgentService, cfg.TraceStore, cfg.ChannelService)
|
||||
notificationsHandler := NewNotificationsHandler(cfg.MsgService, cfg.AgentService, cfg.ChannelService)
|
||||
|
||||
// Wire up SSE broadcaster for real-time events
|
||||
if cfg.Broadcaster != nil {
|
||||
messagesHandler.SetBroadcaster(cfg.Broadcaster)
|
||||
} else if cfg.SSEHub != nil {
|
||||
messagesHandler.SetBroadcaster(NewSSEBroadcaster(cfg.SSEHub, cfg.AgentService, cfg.ChannelService))
|
||||
}
|
||||
|
||||
r.Group(func(r chi.Router) {
|
||||
r.Use(authMiddleware)
|
||||
@@ -109,6 +123,10 @@ func NewRouterWithConfig(cfg RouterConfig) chi.Router {
|
||||
r.Delete("/api/agents/{name}", agentsHandler.DeleteAgent)
|
||||
r.Post("/api/agents/{name}/revoke-key", agentsHandler.RevokeKey)
|
||||
r.Get("/api/agents/{name}/messages", messagesHandler.DMMessages)
|
||||
|
||||
// Notifications
|
||||
r.Get("/api/notifications/unread", notificationsHandler.UnreadCounts)
|
||||
r.Post("/api/notifications/mark-read", notificationsHandler.MarkRead)
|
||||
})
|
||||
|
||||
// API Keys
|
||||
@@ -183,6 +201,38 @@ func NewRouterWithConfig(cfg RouterConfig) chi.Router {
|
||||
r.Get("/api/k8s/job-runs/{id}/logs", k8sHandler.JobRunLogs)
|
||||
})
|
||||
}
|
||||
|
||||
// Push Notifications
|
||||
if cfg.PushService != nil {
|
||||
pushHandler := NewPushHandler(cfg.PushService)
|
||||
// VAPID key endpoint is unauthenticated (needed before subscription)
|
||||
r.Get("/api/push/vapid-key", pushHandler.VAPIDKey)
|
||||
r.Group(func(r chi.Router) {
|
||||
r.Use(authMiddleware)
|
||||
|
||||
r.Post("/api/push/subscribe", pushHandler.Subscribe)
|
||||
r.Delete("/api/push/subscribe", pushHandler.Unsubscribe)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Analytics (authenticated, requires DB)
|
||||
if cfg.DB != nil {
|
||||
analyticsHandler := NewAnalyticsHandler(cfg.DB, cfg.AgentService, cfg.ChannelService)
|
||||
r.Group(func(r chi.Router) {
|
||||
r.Use(authMiddleware)
|
||||
|
||||
r.Get("/api/analytics/timeline", analyticsHandler.Timeline)
|
||||
r.Get("/api/analytics/top-agents", analyticsHandler.TopAgents)
|
||||
r.Get("/api/analytics/top-channels", analyticsHandler.TopChannels)
|
||||
r.Get("/api/analytics/summary", analyticsHandler.Summary)
|
||||
})
|
||||
}
|
||||
|
||||
// Version (unauthenticated)
|
||||
if cfg.Version != "" {
|
||||
versionHandler := NewVersionHandler(cfg.Version)
|
||||
r.Get("/api/version", versionHandler.GetVersion)
|
||||
}
|
||||
|
||||
// Metrics endpoint (unauthenticated, only registered when enabled)
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// VersionHandler serves version information.
|
||||
// The version is set at build time via -ldflags.
|
||||
type VersionHandler struct {
|
||||
version string
|
||||
}
|
||||
|
||||
// NewVersionHandler creates a new version handler.
|
||||
func NewVersionHandler(version string) *VersionHandler {
|
||||
return &VersionHandler{version: version}
|
||||
}
|
||||
|
||||
// GetVersion handles GET /api/version.
|
||||
func (h *VersionHandler) GetVersion(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{
|
||||
"version": h.version,
|
||||
"repo": "https://github.com/synapbus/synapbus",
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGetVersion(t *testing.T) {
|
||||
handler := NewVersionHandler("v0.7.0")
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/version", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
handler.GetVersion(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
ct := rr.Header().Get("Content-Type")
|
||||
if ct != "application/json" {
|
||||
t.Errorf("Content-Type = %q, want application/json", ct)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Version string `json:"version"`
|
||||
Repo string `json:"repo"`
|
||||
}
|
||||
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
if resp.Version != "v0.7.0" {
|
||||
t.Errorf("version = %q, want v0.7.0", resp.Version)
|
||||
}
|
||||
if resp.Repo != "https://github.com/synapbus/synapbus" {
|
||||
t.Errorf("repo = %q, want https://github.com/synapbus/synapbus", resp.Repo)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetVersion_DevBuild(t *testing.T) {
|
||||
handler := NewVersionHandler("dev")
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/version", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
handler.GetVersion(rr, req)
|
||||
|
||||
if rr.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rr.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Version string `json:"version"`
|
||||
Repo string `json:"repo"`
|
||||
}
|
||||
json.Unmarshal(rr.Body.Bytes(), &resp)
|
||||
|
||||
if resp.Version != "dev" {
|
||||
t.Errorf("version = %q, want dev", resp.Version)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetVersion_ResponseFormat(t *testing.T) {
|
||||
handler := NewVersionHandler("v1.2.3")
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/version", nil)
|
||||
rr := httptest.NewRecorder()
|
||||
handler.GetVersion(rr, req)
|
||||
|
||||
// Verify the response is valid JSON with exactly the expected keys
|
||||
var raw map[string]any
|
||||
if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil {
|
||||
t.Fatalf("unmarshal: %v", err)
|
||||
}
|
||||
|
||||
if len(raw) != 2 {
|
||||
t.Errorf("response has %d keys, want 2", len(raw))
|
||||
}
|
||||
|
||||
if _, ok := raw["version"]; !ok {
|
||||
t.Error("response missing 'version' key")
|
||||
}
|
||||
if _, ok := raw["repo"]; !ok {
|
||||
t.Error("response missing 'repo' key")
|
||||
}
|
||||
}
|
||||
@@ -227,6 +227,59 @@ func (h *Handlers) HandleMe(w http.ResponseWriter, r *http.Request) {
|
||||
json.NewEncoder(w).Encode(user)
|
||||
}
|
||||
|
||||
// HandleUpdateProfile handles PUT /api/auth/profile.
|
||||
func (h *Handlers) HandleUpdateProfile(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPut {
|
||||
writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "PUT required")
|
||||
return
|
||||
}
|
||||
|
||||
user, ok := UserFromContext(r.Context())
|
||||
if !ok {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "Not authenticated")
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
DisplayName string `json:"display_name"`
|
||||
}
|
||||
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "Invalid JSON body")
|
||||
return
|
||||
}
|
||||
|
||||
if strings.TrimSpace(req.DisplayName) == "" {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "Display name cannot be empty")
|
||||
return
|
||||
}
|
||||
|
||||
if err := h.userStore.UpdateDisplayName(r.Context(), user.ID, req.DisplayName); err != nil {
|
||||
h.logger.Error("update display name failed", "error", err)
|
||||
writeError(w, http.StatusInternalServerError, "server_error", "Failed to update display name")
|
||||
return
|
||||
}
|
||||
|
||||
// Fetch updated user
|
||||
updated, err := h.userStore.GetUserByID(r.Context(), user.ID)
|
||||
if err != nil {
|
||||
h.logger.Error("fetch updated user failed", "error", err)
|
||||
writeError(w, http.StatusInternalServerError, "server_error", "Profile updated but failed to fetch result")
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]any{
|
||||
"message": "Profile updated",
|
||||
"user": map[string]any{
|
||||
"id": updated.ID,
|
||||
"username": updated.Username,
|
||||
"display_name": updated.DisplayName,
|
||||
"role": updated.Role,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// HandleChangePassword handles PUT /auth/password.
|
||||
func (h *Handlers) HandleChangePassword(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPut {
|
||||
@@ -295,13 +348,21 @@ func (h *Handlers) HandleOAuthMetadata(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
baseURL := h.config.IssuerURL
|
||||
if baseURL == "" {
|
||||
// Fall back to request Host header
|
||||
if baseURL == "" || baseURL == "auto" {
|
||||
// Derive from request headers (supports reverse proxies and tunnels)
|
||||
scheme := "http"
|
||||
if r.TLS != nil {
|
||||
scheme = "https"
|
||||
}
|
||||
baseURL = fmt.Sprintf("%s://%s", scheme, r.Host)
|
||||
// Cloudflare, nginx, and other proxies set these headers
|
||||
if proto := r.Header.Get("X-Forwarded-Proto"); proto != "" {
|
||||
scheme = proto
|
||||
}
|
||||
host := r.Host
|
||||
if fwdHost := r.Header.Get("X-Forwarded-Host"); fwdHost != "" {
|
||||
host = fwdHost
|
||||
}
|
||||
baseURL = fmt.Sprintf("%s://%s", scheme, host)
|
||||
}
|
||||
|
||||
metadata := map[string]any{
|
||||
@@ -816,13 +877,28 @@ const authorizeTemplateHTML = `<!DOCTYPE html>
|
||||
<body>
|
||||
<div class="card">
|
||||
<div class="logo">
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke-width="1.8">
|
||||
<path d="M12 2L2 7l10 5 10-5-10-5z" stroke="#36c5f0"/>
|
||||
<path d="M2 17l10 5 10-5" stroke="#7c3aed"/>
|
||||
<path d="M2 12l10 5 10-5" stroke="url(#g)"/>
|
||||
<defs><linearGradient id="g" x1="2" y1="12" x2="22" y2="17" gradientUnits="userSpaceOnUse">
|
||||
<stop stop-color="#36c5f0"/><stop offset="1" stop-color="#7c3aed"/>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
|
||||
<defs><linearGradient id="bg" x1="0" y1="0" x2="32" y2="32" gradientUnits="userSpaceOnUse">
|
||||
<stop stop-color="#7c3aed"/><stop offset="1" stop-color="#06b6d4"/>
|
||||
</linearGradient></defs>
|
||||
<rect width="32" height="32" rx="7" fill="url(#bg)"/>
|
||||
<g transform="translate(4,4)">
|
||||
<circle cx="12" cy="5" r="1.8" fill="#c4b5fd"/>
|
||||
<circle cx="6" cy="10" r="1.5" fill="#a78bfa"/>
|
||||
<circle cx="18" cy="9" r="1.5" fill="#c4b5fd"/>
|
||||
<circle cx="12" cy="13" r="2" fill="#67e8f9"/>
|
||||
<circle cx="5" cy="17" r="1.5" fill="#a78bfa"/>
|
||||
<circle cx="19" cy="17" r="1.3" fill="#a78bfa"/>
|
||||
<circle cx="11" cy="20" r="1.3" fill="#c4b5fd"/>
|
||||
<line x1="12" y1="5" x2="6" y2="10" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="12" y1="5" x2="18" y2="9" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="6" y1="10" x2="12" y2="13" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="18" y1="9" x2="12" y2="13" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="12" y1="13" x2="5" y2="17" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="12" y1="13" x2="19" y2="17" stroke="white" stroke-width="0.5" opacity="0.5"/>
|
||||
<line x1="5" y1="17" x2="11" y2="20" stroke="white" stroke-width="0.5" opacity="0.3"/>
|
||||
<line x1="6" y1="10" x2="5" y2="17" stroke="white" stroke-width="0.5" opacity="0.3"/>
|
||||
</g>
|
||||
</svg>
|
||||
<h1>SynapBus</h1>
|
||||
<p>Agent Authorization</p>
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// LoadConfig reads environment variables and returns a slice of enabled identity providers.
|
||||
// Providers are only included if both client ID and client secret are set.
|
||||
func LoadConfig(baseURL string) []Provider {
|
||||
var providers []Provider
|
||||
|
||||
// GitHub
|
||||
if clientID, clientSecret := os.Getenv("SYNAPBUS_IDP_GITHUB_CLIENT_ID"), os.Getenv("SYNAPBUS_IDP_GITHUB_CLIENT_SECRET"); clientID != "" && clientSecret != "" {
|
||||
redirectURL := baseURL + "/auth/callback/github"
|
||||
providers = append(providers, NewGitHubProvider(clientID, clientSecret, redirectURL))
|
||||
slog.Info("IdP enabled", "provider", "github")
|
||||
}
|
||||
|
||||
// Google (OIDC)
|
||||
if clientID, clientSecret := os.Getenv("SYNAPBUS_IDP_GOOGLE_CLIENT_ID"), os.Getenv("SYNAPBUS_IDP_GOOGLE_CLIENT_SECRET"); clientID != "" && clientSecret != "" {
|
||||
var allowedDomains []string
|
||||
if domains := os.Getenv("SYNAPBUS_IDP_GOOGLE_ALLOWED_DOMAINS"); domains != "" {
|
||||
for _, d := range strings.Split(domains, ",") {
|
||||
d = strings.TrimSpace(d)
|
||||
if d != "" {
|
||||
allowedDomains = append(allowedDomains, d)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
p, err := NewOIDCProvider(ctx, OIDCConfig{
|
||||
ID: "google",
|
||||
DisplayName: "Google",
|
||||
IssuerURL: "https://accounts.google.com",
|
||||
ClientID: clientID,
|
||||
ClientSecret: clientSecret,
|
||||
RedirectURL: baseURL + "/auth/callback/google",
|
||||
AllowedDomains: allowedDomains,
|
||||
})
|
||||
if err != nil {
|
||||
slog.Error("failed to initialize Google OIDC provider", "error", err)
|
||||
} else {
|
||||
providers = append(providers, p)
|
||||
slog.Info("IdP enabled", "provider", "google", "allowed_domains", allowedDomains)
|
||||
}
|
||||
}
|
||||
|
||||
// Azure AD (OIDC)
|
||||
if clientID, clientSecret := os.Getenv("SYNAPBUS_IDP_AZUREAD_CLIENT_ID"), os.Getenv("SYNAPBUS_IDP_AZUREAD_CLIENT_SECRET"); clientID != "" && clientSecret != "" {
|
||||
tenantID := os.Getenv("SYNAPBUS_IDP_AZUREAD_TENANT_ID")
|
||||
if tenantID == "" {
|
||||
tenantID = "common" // multi-tenant by default
|
||||
}
|
||||
|
||||
var groupMapping map[string]string
|
||||
if gm := os.Getenv("SYNAPBUS_IDP_AZUREAD_GROUP_MAPPING"); gm != "" {
|
||||
if err := json.Unmarshal([]byte(gm), &groupMapping); err != nil {
|
||||
slog.Error("failed to parse Azure AD group mapping", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
issuerURL := "https://login.microsoftonline.com/" + tenantID + "/v2.0"
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
p, err := NewOIDCProvider(ctx, OIDCConfig{
|
||||
ID: "azuread",
|
||||
DisplayName: "Microsoft",
|
||||
IssuerURL: issuerURL,
|
||||
ClientID: clientID,
|
||||
ClientSecret: clientSecret,
|
||||
RedirectURL: baseURL + "/auth/callback/azuread",
|
||||
GroupMapping: groupMapping,
|
||||
})
|
||||
if err != nil {
|
||||
slog.Error("failed to initialize Azure AD OIDC provider", "error", err)
|
||||
} else {
|
||||
providers = append(providers, p)
|
||||
slog.Info("IdP enabled", "provider", "azuread", "tenant_id", tenantID)
|
||||
}
|
||||
}
|
||||
|
||||
return providers
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"golang.org/x/oauth2"
|
||||
"golang.org/x/oauth2/github"
|
||||
)
|
||||
|
||||
// GitHubProvider implements GitHub OAuth authentication.
|
||||
// GitHub does not support OIDC discovery, so this uses plain OAuth 2.0
|
||||
// with GitHub's user API endpoints.
|
||||
type GitHubProvider struct {
|
||||
config *oauth2.Config
|
||||
}
|
||||
|
||||
// NewGitHubProvider creates a new GitHub OAuth provider.
|
||||
func NewGitHubProvider(clientID, clientSecret, redirectURL string) *GitHubProvider {
|
||||
return &GitHubProvider{
|
||||
config: &oauth2.Config{
|
||||
ClientID: clientID,
|
||||
ClientSecret: clientSecret,
|
||||
RedirectURL: redirectURL,
|
||||
Scopes: []string{"read:user", "user:email"},
|
||||
Endpoint: github.Endpoint,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (p *GitHubProvider) ID() string { return "github" }
|
||||
func (p *GitHubProvider) Type() string { return "oauth" }
|
||||
func (p *GitHubProvider) DisplayName() string { return "GitHub" }
|
||||
|
||||
func (p *GitHubProvider) AuthCodeURL(state string) string {
|
||||
return p.config.AuthCodeURL(state)
|
||||
}
|
||||
|
||||
func (p *GitHubProvider) Exchange(ctx context.Context, code string) (*ExternalUser, error) {
|
||||
token, err := p.config.Exchange(ctx, code)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("github: exchange code: %w", err)
|
||||
}
|
||||
|
||||
client := p.config.Client(ctx, token)
|
||||
|
||||
// Fetch user profile
|
||||
userInfo, err := fetchGitHubUser(client)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Fetch primary verified email
|
||||
email, err := fetchGitHubPrimaryEmail(client)
|
||||
if err != nil {
|
||||
// Non-fatal: email might not be available
|
||||
email = ""
|
||||
}
|
||||
|
||||
// If user profile has an email and we didn't get one from the emails endpoint, use it
|
||||
if email == "" {
|
||||
if e, ok := userInfo["email"].(string); ok && e != "" {
|
||||
email = e
|
||||
}
|
||||
}
|
||||
|
||||
idNum, _ := userInfo["id"].(float64)
|
||||
login, _ := userInfo["login"].(string)
|
||||
name, _ := userInfo["name"].(string)
|
||||
|
||||
return &ExternalUser{
|
||||
ProviderID: "github",
|
||||
ExternalID: strconv.FormatInt(int64(idNum), 10),
|
||||
Email: email,
|
||||
Name: name,
|
||||
Username: login,
|
||||
RawClaims: userInfo,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func fetchGitHubUser(client *http.Client) (map[string]any, error) {
|
||||
resp, err := client.Get("https://api.github.com/user")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("github: fetch user: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("github: user API returned %d: %s", resp.StatusCode, body)
|
||||
}
|
||||
|
||||
var user map[string]any
|
||||
if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
|
||||
return nil, fmt.Errorf("github: decode user: %w", err)
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// githubEmail represents an email entry from the GitHub emails API.
|
||||
type githubEmail struct {
|
||||
Email string `json:"email"`
|
||||
Primary bool `json:"primary"`
|
||||
Verified bool `json:"verified"`
|
||||
}
|
||||
|
||||
func fetchGitHubPrimaryEmail(client *http.Client) (string, error) {
|
||||
resp, err := client.Get("https://api.github.com/user/emails")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("github: fetch emails: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return "", fmt.Errorf("github: emails API returned %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
var emails []githubEmail
|
||||
if err := json.NewDecoder(resp.Body).Decode(&emails); err != nil {
|
||||
return "", fmt.Errorf("github: decode emails: %w", err)
|
||||
}
|
||||
|
||||
// Find primary verified email
|
||||
for _, e := range emails {
|
||||
if e.Primary && e.Verified {
|
||||
return e.Email, nil
|
||||
}
|
||||
}
|
||||
// Fallback: first verified email
|
||||
for _, e := range emails {
|
||||
if e.Verified {
|
||||
return e.Email, nil
|
||||
}
|
||||
}
|
||||
return "", fmt.Errorf("github: no verified email found")
|
||||
}
|
||||
@@ -0,0 +1,349 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/synapbus/synapbus/internal/auth"
|
||||
)
|
||||
|
||||
// AgentProvisioner creates a human agent and personal channel after IdP login.
|
||||
// This is a narrow interface to avoid importing the agents/channels packages.
|
||||
type AgentProvisioner interface {
|
||||
ProvisionHumanAgent(ctx context.Context, username, displayName string, ownerID int64) error
|
||||
}
|
||||
|
||||
// Handlers holds HTTP handlers for external identity provider authentication.
|
||||
type Handlers struct {
|
||||
providers map[string]Provider
|
||||
providerList []Provider // preserve order for listing
|
||||
idStore *UserIdentityStore
|
||||
userStore auth.UserStore
|
||||
sessionStore auth.SessionStore
|
||||
agentProvisioner AgentProvisioner
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewHandlers creates a new set of IdP HTTP handlers.
|
||||
func NewHandlers(
|
||||
providers []Provider,
|
||||
idStore *UserIdentityStore,
|
||||
userStore auth.UserStore,
|
||||
sessionStore auth.SessionStore,
|
||||
agentProvisioner AgentProvisioner,
|
||||
) *Handlers {
|
||||
providerMap := make(map[string]Provider, len(providers))
|
||||
for _, p := range providers {
|
||||
providerMap[p.ID()] = p
|
||||
}
|
||||
return &Handlers{
|
||||
providers: providerMap,
|
||||
providerList: providers,
|
||||
idStore: idStore,
|
||||
userStore: userStore,
|
||||
sessionStore: sessionStore,
|
||||
agentProvisioner: agentProvisioner,
|
||||
logger: slog.Default().With("component", "idp"),
|
||||
}
|
||||
}
|
||||
|
||||
// HandleListProviders returns the list of enabled identity providers.
|
||||
// GET /auth/providers
|
||||
func (h *Handlers) HandleListProviders(w http.ResponseWriter, r *http.Request) {
|
||||
providers := make([]ProviderInfo, 0, len(h.providerList))
|
||||
for _, p := range h.providerList {
|
||||
providers = append(providers, ProviderInfo{
|
||||
ID: p.ID(),
|
||||
Type: p.Type(),
|
||||
DisplayName: p.DisplayName(),
|
||||
})
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]any{
|
||||
"providers": providers,
|
||||
})
|
||||
}
|
||||
|
||||
// HandleLogin initiates the OAuth/OIDC flow by redirecting to the IdP.
|
||||
// GET /auth/login/{provider}
|
||||
func (h *Handlers) HandleLogin(w http.ResponseWriter, r *http.Request) {
|
||||
providerID := chi.URLParam(r, "provider")
|
||||
provider, ok := h.providers[providerID]
|
||||
if !ok {
|
||||
http.Error(w, fmt.Sprintf(`{"error":"unknown_provider","message":"Provider %q not found"}`, providerID), http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
state, err := generateState()
|
||||
if err != nil {
|
||||
h.logger.Error("failed to generate state", "error", err)
|
||||
http.Error(w, `{"error":"server_error","message":"Failed to generate state"}`, http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Store state in a short-lived cookie for CSRF protection
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: "idp_state",
|
||||
Value: state,
|
||||
Path: "/auth/callback/" + providerID,
|
||||
HttpOnly: true,
|
||||
SameSite: http.SameSiteLaxMode,
|
||||
MaxAge: 600, // 10 minutes
|
||||
})
|
||||
|
||||
authURL := provider.AuthCodeURL(state)
|
||||
http.Redirect(w, r, authURL, http.StatusTemporaryRedirect)
|
||||
}
|
||||
|
||||
// HandleCallback processes the OAuth/OIDC callback from the IdP.
|
||||
// GET /auth/callback/{provider}
|
||||
func (h *Handlers) HandleCallback(w http.ResponseWriter, r *http.Request) {
|
||||
providerID := chi.URLParam(r, "provider")
|
||||
provider, ok := h.providers[providerID]
|
||||
if !ok {
|
||||
http.Error(w, "Unknown provider", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
// Verify state parameter
|
||||
stateCookie, err := r.Cookie("idp_state")
|
||||
if err != nil || stateCookie.Value == "" {
|
||||
http.Error(w, "Missing state cookie", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if r.URL.Query().Get("state") != stateCookie.Value {
|
||||
http.Error(w, "State mismatch — possible CSRF attack", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Clear state cookie
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: "idp_state",
|
||||
Value: "",
|
||||
Path: "/auth/callback/" + providerID,
|
||||
HttpOnly: true,
|
||||
MaxAge: -1,
|
||||
})
|
||||
|
||||
// Check for error from IdP
|
||||
if errParam := r.URL.Query().Get("error"); errParam != "" {
|
||||
desc := r.URL.Query().Get("error_description")
|
||||
h.logger.Warn("IdP returned error", "provider", providerID, "error", errParam, "description", desc)
|
||||
http.Redirect(w, r, "/login?error="+errParam, http.StatusTemporaryRedirect)
|
||||
return
|
||||
}
|
||||
|
||||
code := r.URL.Query().Get("code")
|
||||
if code == "" {
|
||||
http.Error(w, "Missing authorization code", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Exchange code for user info
|
||||
extUser, err := provider.Exchange(r.Context(), code)
|
||||
if err != nil {
|
||||
h.logger.Error("IdP exchange failed", "provider", providerID, "error", err)
|
||||
http.Redirect(w, r, "/login?error=exchange_failed", http.StatusTemporaryRedirect)
|
||||
return
|
||||
}
|
||||
|
||||
// Find or create local user
|
||||
user, err := h.findOrCreateUser(r.Context(), extUser)
|
||||
if err != nil {
|
||||
h.logger.Error("failed to provision user from IdP", "provider", providerID, "error", err)
|
||||
http.Redirect(w, r, "/login?error=provisioning_failed", http.StatusTemporaryRedirect)
|
||||
return
|
||||
}
|
||||
|
||||
// Create session
|
||||
session, err := h.sessionStore.CreateSession(r.Context(), user.ID, 24*time.Hour)
|
||||
if err != nil {
|
||||
h.logger.Error("failed to create session after IdP login", "error", err)
|
||||
http.Error(w, "Failed to create session", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Set session cookie
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: auth.SessionCookieName,
|
||||
Value: session.SessionID,
|
||||
Path: "/",
|
||||
HttpOnly: true,
|
||||
SameSite: http.SameSiteLaxMode,
|
||||
MaxAge: 86400, // 24 hours
|
||||
})
|
||||
|
||||
auth.LogAuthEvent(r.Context(), h.logger, auth.AuthEvent{
|
||||
Type: auth.EventLoginSuccess,
|
||||
UserID: user.ID,
|
||||
Username: user.Username,
|
||||
RemoteIP: r.RemoteAddr,
|
||||
Details: map[string]any{
|
||||
"provider": providerID,
|
||||
"external_id": extUser.ExternalID,
|
||||
},
|
||||
})
|
||||
|
||||
// Ensure human agent and channel in background
|
||||
if h.agentProvisioner != nil {
|
||||
go func() {
|
||||
ctx := context.Background()
|
||||
if err := h.agentProvisioner.ProvisionHumanAgent(ctx, user.Username, user.DisplayName, user.ID); err != nil {
|
||||
h.logger.Warn("failed to ensure human agent after IdP login", "username", user.Username, "error", err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// Redirect to home
|
||||
http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
|
||||
}
|
||||
|
||||
// findOrCreateUser looks up or provisions a local user from external identity.
|
||||
// 1. Check user_identities for (provider, external_id) -> if found, load user
|
||||
// 2. If not found, check users by email -> if found, link identity
|
||||
// 3. If no user at all, create new user with random password
|
||||
func (h *Handlers) findOrCreateUser(ctx context.Context, ext *ExternalUser) (*auth.User, error) {
|
||||
// Step 1: Check existing identity link
|
||||
userID, err := h.idStore.FindByProvider(ctx, ext.ProviderID, ext.ExternalID)
|
||||
if err == nil {
|
||||
// Found existing link
|
||||
user, err := h.userStore.GetUserByID(ctx, userID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("load linked user %d: %w", userID, err)
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
if err != sql.ErrNoRows {
|
||||
return nil, fmt.Errorf("find identity: %w", err)
|
||||
}
|
||||
|
||||
// Step 2: Try to find user by email
|
||||
if ext.Email != "" {
|
||||
user, err := h.userStore.GetUserByEmail(ctx, ext.Email)
|
||||
if err == nil {
|
||||
// Found user with matching email — link this identity
|
||||
if linkErr := h.idStore.Create(ctx, user.ID, ext.ProviderID, ext.ExternalID, ext.Email, ext.Name, ext.RawClaims); linkErr != nil {
|
||||
h.logger.Warn("failed to link identity to existing user", "user_id", user.ID, "error", linkErr)
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
// If error is not "not found", it's a real error
|
||||
if err != auth.ErrUserNotFound {
|
||||
return nil, fmt.Errorf("find user by email: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Step 3: Create new user
|
||||
username := sanitizeUsername(ext.Username, ext.ProviderID, ext.ExternalID)
|
||||
displayName := ext.Name
|
||||
if displayName == "" {
|
||||
displayName = username
|
||||
}
|
||||
|
||||
// Generate random password (user will login via IdP)
|
||||
randomPW, err := generateRandomPassword()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("generate password: %w", err)
|
||||
}
|
||||
|
||||
user, err := h.userStore.CreateUser(ctx, username, randomPW, displayName)
|
||||
if err != nil {
|
||||
// If username conflicts, try with a suffix
|
||||
if strings.Contains(err.Error(), "already exists") {
|
||||
suffix, _ := generateShortID()
|
||||
username = username + "_" + suffix
|
||||
user, err = h.userStore.CreateUser(ctx, username, randomPW, displayName)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create user: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Set email on the user if available
|
||||
if ext.Email != "" {
|
||||
if emailStore, ok := h.userStore.(*auth.SQLiteUserStore); ok {
|
||||
emailStore.SetEmail(ctx, user.ID, ext.Email)
|
||||
}
|
||||
}
|
||||
|
||||
// Link identity
|
||||
if linkErr := h.idStore.Create(ctx, user.ID, ext.ProviderID, ext.ExternalID, ext.Email, ext.Name, ext.RawClaims); linkErr != nil {
|
||||
h.logger.Warn("failed to link identity to new user", "user_id", user.ID, "error", linkErr)
|
||||
}
|
||||
|
||||
h.logger.Info("provisioned new user from IdP",
|
||||
"username", username,
|
||||
"provider", ext.ProviderID,
|
||||
"external_id", ext.ExternalID,
|
||||
"email", ext.Email,
|
||||
)
|
||||
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// sanitizeUsername normalizes a username from an IdP to match SynapBus requirements.
|
||||
// Usernames must be 3-64 chars, alphanumeric and underscore only.
|
||||
func sanitizeUsername(username, provider, externalID string) string {
|
||||
if username == "" {
|
||||
username = provider + "_" + externalID
|
||||
}
|
||||
|
||||
// Replace invalid characters with underscore
|
||||
var result strings.Builder
|
||||
for _, r := range username {
|
||||
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' {
|
||||
result.WriteRune(r)
|
||||
} else {
|
||||
result.WriteRune('_')
|
||||
}
|
||||
}
|
||||
username = result.String()
|
||||
|
||||
// Trim underscores from edges and ensure minimum length
|
||||
username = strings.Trim(username, "_")
|
||||
if len(username) < 3 {
|
||||
username = username + "_user"
|
||||
}
|
||||
if len(username) > 64 {
|
||||
username = username[:64]
|
||||
}
|
||||
|
||||
return username
|
||||
}
|
||||
|
||||
// generateState creates a cryptographically random state parameter for OAuth.
|
||||
func generateState() (string, error) {
|
||||
b := make([]byte, 16)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(b), nil
|
||||
}
|
||||
|
||||
// generateRandomPassword creates a random password for IdP-provisioned users.
|
||||
func generateRandomPassword() (string, error) {
|
||||
b := make([]byte, 32)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(b), nil
|
||||
}
|
||||
|
||||
// generateShortID creates a short random string for username disambiguation.
|
||||
func generateShortID() (string, error) {
|
||||
b := make([]byte, 3)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(b), nil
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/auth"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
)
|
||||
|
||||
func newTestDB(t *testing.T) *sql.DB {
|
||||
t.Helper()
|
||||
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", t.Name())
|
||||
db, err := sql.Open("sqlite", dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("open database: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { db.Close() })
|
||||
|
||||
if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
|
||||
t.Fatalf("enable foreign keys: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
if err := storage.RunMigrations(ctx, db); err != nil {
|
||||
t.Fatalf("run migrations: %v", err)
|
||||
}
|
||||
|
||||
return db
|
||||
}
|
||||
|
||||
func newTestUserStore(db *sql.DB, t *testing.T) auth.UserStore {
|
||||
t.Helper()
|
||||
return auth.NewSQLiteUserStore(db, 10) // low cost for fast tests
|
||||
}
|
||||
|
||||
// --- GitHub provider tests ---
|
||||
|
||||
func TestGitHubProvider_AuthCodeURL(t *testing.T) {
|
||||
p := NewGitHubProvider("test-client-id", "test-secret", "http://localhost:8080/auth/callback/github")
|
||||
|
||||
url := p.AuthCodeURL("test-state-123")
|
||||
|
||||
if url == "" {
|
||||
t.Fatal("AuthCodeURL returned empty string")
|
||||
}
|
||||
if p.ID() != "github" {
|
||||
t.Errorf("ID() = %q, want %q", p.ID(), "github")
|
||||
}
|
||||
if p.Type() != "oauth" {
|
||||
t.Errorf("Type() = %q, want %q", p.Type(), "oauth")
|
||||
}
|
||||
if p.DisplayName() != "GitHub" {
|
||||
t.Errorf("DisplayName() = %q, want %q", p.DisplayName(), "GitHub")
|
||||
}
|
||||
|
||||
// URL should contain the client ID and state
|
||||
if got := url; got == "" {
|
||||
t.Error("expected non-empty URL")
|
||||
}
|
||||
}
|
||||
|
||||
// --- OIDC domain validation tests ---
|
||||
|
||||
func TestOIDCProvider_DomainRestriction(t *testing.T) {
|
||||
p := &OIDCProvider{
|
||||
id: "test",
|
||||
displayName: "Test",
|
||||
allowedDomains: []string{"gcore.com", "example.com"},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
email string
|
||||
hd string
|
||||
wantError bool
|
||||
}{
|
||||
{"allowed domain via hd", "user@gcore.com", "gcore.com", false},
|
||||
{"allowed domain via email", "user@example.com", "", false},
|
||||
{"disallowed domain", "user@evil.com", "evil.com", true},
|
||||
{"no domain info", "", "", true},
|
||||
{"case insensitive", "User@Gcore.COM", "Gcore.COM", false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := p.validateDomain(tt.email, tt.hd)
|
||||
if (err != nil) != tt.wantError {
|
||||
t.Errorf("validateDomain(%q, %q) error = %v, wantError %v", tt.email, tt.hd, err, tt.wantError)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOIDCProvider_NoDomainRestriction(t *testing.T) {
|
||||
p := &OIDCProvider{
|
||||
id: "test",
|
||||
displayName: "Test",
|
||||
allowedDomains: nil,
|
||||
}
|
||||
|
||||
if len(p.allowedDomains) != 0 {
|
||||
t.Error("expected empty allowed domains")
|
||||
}
|
||||
}
|
||||
|
||||
// --- Store tests ---
|
||||
|
||||
func TestUserIdentityStore_CreateAndFind(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewUserIdentityStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
// Create a user first
|
||||
_, err := db.ExecContext(ctx,
|
||||
`INSERT INTO users (username, password_hash, display_name, role) VALUES (?, ?, ?, ?)`,
|
||||
"testuser", "hash", "Test User", "user",
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("create user: %v", err)
|
||||
}
|
||||
|
||||
var userID int64
|
||||
db.QueryRowContext(ctx, "SELECT id FROM users WHERE username = ?", "testuser").Scan(&userID)
|
||||
|
||||
// Create identity
|
||||
claims := map[string]any{"sub": "12345", "login": "ghuser"}
|
||||
err = store.Create(ctx, userID, "github", "12345", "test@example.com", "Test User", claims)
|
||||
if err != nil {
|
||||
t.Fatalf("Create: %v", err)
|
||||
}
|
||||
|
||||
// Find by provider
|
||||
foundID, err := store.FindByProvider(ctx, "github", "12345")
|
||||
if err != nil {
|
||||
t.Fatalf("FindByProvider: %v", err)
|
||||
}
|
||||
if foundID != userID {
|
||||
t.Errorf("FindByProvider = %d, want %d", foundID, userID)
|
||||
}
|
||||
|
||||
// Find non-existent
|
||||
_, err = store.FindByProvider(ctx, "github", "99999")
|
||||
if err != sql.ErrNoRows {
|
||||
t.Errorf("expected sql.ErrNoRows, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserIdentityStore_ListByUser(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewUserIdentityStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
_, err := db.ExecContext(ctx,
|
||||
`INSERT INTO users (username, password_hash, display_name, role) VALUES (?, ?, ?, ?)`,
|
||||
"multiuser", "hash", "Multi User", "user",
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("create user: %v", err)
|
||||
}
|
||||
|
||||
var userID int64
|
||||
db.QueryRowContext(ctx, "SELECT id FROM users WHERE username = ?", "multiuser").Scan(&userID)
|
||||
|
||||
store.Create(ctx, userID, "github", "gh-123", "user@gh.com", "GH User", map[string]any{})
|
||||
store.Create(ctx, userID, "google", "goog-456", "user@google.com", "Google User", map[string]any{})
|
||||
|
||||
identities, err := store.ListByUser(ctx, userID)
|
||||
if err != nil {
|
||||
t.Fatalf("ListByUser: %v", err)
|
||||
}
|
||||
if len(identities) != 2 {
|
||||
t.Errorf("got %d identities, want 2", len(identities))
|
||||
}
|
||||
|
||||
if identities[0].Provider != "github" {
|
||||
t.Errorf("first identity provider = %q, want %q", identities[0].Provider, "github")
|
||||
}
|
||||
if identities[1].Provider != "google" {
|
||||
t.Errorf("second identity provider = %q, want %q", identities[1].Provider, "google")
|
||||
}
|
||||
|
||||
empty, err := store.ListByUser(ctx, 99999)
|
||||
if err != nil {
|
||||
t.Fatalf("ListByUser (empty): %v", err)
|
||||
}
|
||||
if len(empty) != 0 {
|
||||
t.Errorf("expected empty list, got %d", len(empty))
|
||||
}
|
||||
}
|
||||
|
||||
// --- Handler tests ---
|
||||
|
||||
func TestHandleListProviders(t *testing.T) {
|
||||
providers := []Provider{
|
||||
NewGitHubProvider("id", "secret", "http://localhost/callback"),
|
||||
&mockProvider{id: "google", providerType: "oidc", name: "Google"},
|
||||
}
|
||||
|
||||
handlers := NewHandlers(providers, nil, nil, nil, nil)
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/auth/providers", nil)
|
||||
w := httptest.NewRecorder()
|
||||
|
||||
handlers.HandleListProviders(w, req)
|
||||
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", w.Code, http.StatusOK)
|
||||
}
|
||||
|
||||
var resp struct {
|
||||
Providers []ProviderInfo `json:"providers"`
|
||||
}
|
||||
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
|
||||
t.Fatalf("decode response: %v", err)
|
||||
}
|
||||
|
||||
if len(resp.Providers) != 2 {
|
||||
t.Fatalf("got %d providers, want 2", len(resp.Providers))
|
||||
}
|
||||
|
||||
if resp.Providers[0].ID != "github" {
|
||||
t.Errorf("first provider ID = %q, want %q", resp.Providers[0].ID, "github")
|
||||
}
|
||||
if resp.Providers[0].DisplayName != "GitHub" {
|
||||
t.Errorf("first provider DisplayName = %q, want %q", resp.Providers[0].DisplayName, "GitHub")
|
||||
}
|
||||
if resp.Providers[1].ID != "google" {
|
||||
t.Errorf("second provider ID = %q, want %q", resp.Providers[1].ID, "google")
|
||||
}
|
||||
}
|
||||
|
||||
// --- User provisioning tests ---
|
||||
|
||||
func TestSanitizeUsername(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
username string
|
||||
provider string
|
||||
externalID string
|
||||
wantMin string // exact match, or empty for length-only check
|
||||
maxLen int
|
||||
}{
|
||||
{"normal", "testuser", "github", "123", "testuser", 0},
|
||||
{"with dash", "test-user", "github", "123", "test_user", 0},
|
||||
{"with dots", "test.user", "github", "123", "test_user", 0},
|
||||
{"with at sign", "user@email.com", "github", "123", "user_email_com", 0},
|
||||
{"too short", "ab", "github", "123", "ab_user", 0},
|
||||
{"empty", "", "github", "123", "github_123", 0},
|
||||
{"too long", "", "", "", "", 64},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
input := tt.username
|
||||
if tt.name == "too long" {
|
||||
b := make([]byte, 100)
|
||||
for i := range b {
|
||||
b[i] = 'a'
|
||||
}
|
||||
input = string(b)
|
||||
}
|
||||
got := sanitizeUsername(input, tt.provider, tt.externalID)
|
||||
if tt.maxLen > 0 {
|
||||
if len(got) > tt.maxLen {
|
||||
t.Errorf("sanitizeUsername too long: len=%d, want <= %d", len(got), tt.maxLen)
|
||||
}
|
||||
return
|
||||
}
|
||||
if got != tt.wantMin {
|
||||
t.Errorf("sanitizeUsername(%q, %q, %q) = %q, want %q", tt.username, tt.provider, tt.externalID, got, tt.wantMin)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFindOrCreateUser_NewUser(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
idStore := NewUserIdentityStore(db)
|
||||
userStore := newTestUserStore(db, t)
|
||||
|
||||
handlers := &Handlers{
|
||||
idStore: idStore,
|
||||
userStore: userStore,
|
||||
logger: slog.Default(),
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
ext := &ExternalUser{
|
||||
ProviderID: "github",
|
||||
ExternalID: "gh-newuser-001",
|
||||
Email: "newuser@example.com",
|
||||
Name: "New User",
|
||||
Username: "newghuser",
|
||||
RawClaims: map[string]any{"login": "newghuser"},
|
||||
}
|
||||
|
||||
user, err := handlers.findOrCreateUser(ctx, ext)
|
||||
if err != nil {
|
||||
t.Fatalf("findOrCreateUser: %v", err)
|
||||
}
|
||||
|
||||
if user.Username != "newghuser" {
|
||||
t.Errorf("Username = %q, want %q", user.Username, "newghuser")
|
||||
}
|
||||
if user.DisplayName != "New User" {
|
||||
t.Errorf("DisplayName = %q, want %q", user.DisplayName, "New User")
|
||||
}
|
||||
|
||||
// Identity should be linked
|
||||
foundID, err := idStore.FindByProvider(ctx, "github", "gh-newuser-001")
|
||||
if err != nil {
|
||||
t.Fatalf("identity not linked: %v", err)
|
||||
}
|
||||
if foundID != user.ID {
|
||||
t.Errorf("linked user ID = %d, want %d", foundID, user.ID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFindOrCreateUser_ExistingIdentity(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
idStore := NewUserIdentityStore(db)
|
||||
userStore := newTestUserStore(db, t)
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
// Create a user first
|
||||
user, err := userStore.CreateUser(ctx, "existinguser", "password1234", "Existing User")
|
||||
if err != nil {
|
||||
t.Fatalf("CreateUser: %v", err)
|
||||
}
|
||||
|
||||
// Link identity manually
|
||||
err = idStore.Create(ctx, user.ID, "github", "gh-existing-001", "existing@example.com", "Existing", map[string]any{})
|
||||
if err != nil {
|
||||
t.Fatalf("Create identity: %v", err)
|
||||
}
|
||||
|
||||
handlers := &Handlers{
|
||||
idStore: idStore,
|
||||
userStore: userStore,
|
||||
logger: slog.Default(),
|
||||
}
|
||||
|
||||
ext := &ExternalUser{
|
||||
ProviderID: "github",
|
||||
ExternalID: "gh-existing-001",
|
||||
Email: "existing@example.com",
|
||||
Name: "Existing User",
|
||||
Username: "existinguser",
|
||||
}
|
||||
|
||||
found, err := handlers.findOrCreateUser(ctx, ext)
|
||||
if err != nil {
|
||||
t.Fatalf("findOrCreateUser: %v", err)
|
||||
}
|
||||
if found.ID != user.ID {
|
||||
t.Errorf("found user ID = %d, want %d", found.ID, user.ID)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Mock helpers ---
|
||||
|
||||
type mockProvider struct {
|
||||
id string
|
||||
providerType string
|
||||
name string
|
||||
}
|
||||
|
||||
func (m *mockProvider) ID() string { return m.id }
|
||||
func (m *mockProvider) Type() string { return m.providerType }
|
||||
func (m *mockProvider) DisplayName() string { return m.name }
|
||||
func (m *mockProvider) AuthCodeURL(state string) string {
|
||||
return "https://mock.idp.example.com/authorize?state=" + state
|
||||
}
|
||||
func (m *mockProvider) Exchange(ctx context.Context, code string) (*ExternalUser, error) {
|
||||
return &ExternalUser{
|
||||
ProviderID: m.id,
|
||||
ExternalID: "mock-ext-id",
|
||||
Email: "mock@example.com",
|
||||
Name: "Mock User",
|
||||
Username: "mockuser",
|
||||
}, nil
|
||||
}
|
||||
@@ -0,0 +1,174 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/coreos/go-oidc/v3/oidc"
|
||||
"golang.org/x/oauth2"
|
||||
)
|
||||
|
||||
// OIDCProvider implements OpenID Connect authentication.
|
||||
// Works with any OIDC-compliant provider (Google, Azure AD, etc.).
|
||||
type OIDCProvider struct {
|
||||
id string
|
||||
displayName string
|
||||
issuerURL string
|
||||
config *oauth2.Config
|
||||
verifier *oidc.IDTokenVerifier
|
||||
allowedDomains []string // Empty means allow all domains
|
||||
groupMapping map[string]string
|
||||
}
|
||||
|
||||
// OIDCConfig holds configuration for an OIDC provider.
|
||||
type OIDCConfig struct {
|
||||
ID string
|
||||
DisplayName string
|
||||
IssuerURL string
|
||||
ClientID string
|
||||
ClientSecret string
|
||||
RedirectURL string
|
||||
Scopes []string
|
||||
AllowedDomains []string
|
||||
GroupMapping map[string]string
|
||||
}
|
||||
|
||||
// NewOIDCProvider creates a new OIDC provider using discovery.
|
||||
func NewOIDCProvider(ctx context.Context, cfg OIDCConfig) (*OIDCProvider, error) {
|
||||
provider, err := oidc.NewProvider(ctx, cfg.IssuerURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("oidc: discover %s: %w", cfg.IssuerURL, err)
|
||||
}
|
||||
|
||||
scopes := cfg.Scopes
|
||||
if len(scopes) == 0 {
|
||||
scopes = []string{oidc.ScopeOpenID, "email", "profile"}
|
||||
}
|
||||
|
||||
oauthConfig := &oauth2.Config{
|
||||
ClientID: cfg.ClientID,
|
||||
ClientSecret: cfg.ClientSecret,
|
||||
RedirectURL: cfg.RedirectURL,
|
||||
Endpoint: provider.Endpoint(),
|
||||
Scopes: scopes,
|
||||
}
|
||||
|
||||
verifier := provider.Verifier(&oidc.Config{
|
||||
ClientID: cfg.ClientID,
|
||||
})
|
||||
|
||||
return &OIDCProvider{
|
||||
id: cfg.ID,
|
||||
displayName: cfg.DisplayName,
|
||||
issuerURL: cfg.IssuerURL,
|
||||
config: oauthConfig,
|
||||
verifier: verifier,
|
||||
allowedDomains: cfg.AllowedDomains,
|
||||
groupMapping: cfg.GroupMapping,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (p *OIDCProvider) ID() string { return p.id }
|
||||
func (p *OIDCProvider) Type() string { return "oidc" }
|
||||
func (p *OIDCProvider) DisplayName() string { return p.displayName }
|
||||
|
||||
func (p *OIDCProvider) AuthCodeURL(state string) string {
|
||||
return p.config.AuthCodeURL(state)
|
||||
}
|
||||
|
||||
func (p *OIDCProvider) Exchange(ctx context.Context, code string) (*ExternalUser, error) {
|
||||
token, err := p.config.Exchange(ctx, code)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("oidc: exchange code: %w", err)
|
||||
}
|
||||
|
||||
rawIDToken, ok := token.Extra("id_token").(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("oidc: no id_token in response")
|
||||
}
|
||||
|
||||
idToken, err := p.verifier.Verify(ctx, rawIDToken)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("oidc: verify id_token: %w", err)
|
||||
}
|
||||
|
||||
// Extract claims
|
||||
var claims struct {
|
||||
Sub string `json:"sub"`
|
||||
Email string `json:"email"`
|
||||
Name string `json:"name"`
|
||||
Username string `json:"preferred_username"`
|
||||
HD string `json:"hd"` // Google hosted domain
|
||||
Groups []string `json:"groups"`
|
||||
}
|
||||
if err := idToken.Claims(&claims); err != nil {
|
||||
return nil, fmt.Errorf("oidc: parse claims: %w", err)
|
||||
}
|
||||
|
||||
// Extract raw claims for storage
|
||||
var rawClaims map[string]any
|
||||
if err := idToken.Claims(&rawClaims); err != nil {
|
||||
rawClaims = map[string]any{"sub": claims.Sub}
|
||||
}
|
||||
|
||||
// Validate domain restriction
|
||||
if len(p.allowedDomains) > 0 {
|
||||
if err := p.validateDomain(claims.Email, claims.HD); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// Map groups through group mapping
|
||||
var mappedGroups []string
|
||||
if len(p.groupMapping) > 0 {
|
||||
for _, group := range claims.Groups {
|
||||
if mapped, ok := p.groupMapping[group]; ok {
|
||||
mappedGroups = append(mappedGroups, mapped)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
mappedGroups = claims.Groups
|
||||
}
|
||||
|
||||
// Derive username from email if preferred_username is empty
|
||||
username := claims.Username
|
||||
if username == "" && claims.Email != "" {
|
||||
parts := strings.SplitN(claims.Email, "@", 2)
|
||||
username = parts[0]
|
||||
}
|
||||
|
||||
return &ExternalUser{
|
||||
ProviderID: p.id,
|
||||
ExternalID: claims.Sub,
|
||||
Email: claims.Email,
|
||||
Name: claims.Name,
|
||||
Username: username,
|
||||
Groups: mappedGroups,
|
||||
RawClaims: rawClaims,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// validateDomain checks that the user's email domain is in the allowed list.
|
||||
func (p *OIDCProvider) validateDomain(email, hostedDomain string) error {
|
||||
// Prefer hd (hosted domain) claim when available (Google Workspace)
|
||||
domain := hostedDomain
|
||||
if domain == "" && email != "" {
|
||||
parts := strings.SplitN(email, "@", 2)
|
||||
if len(parts) == 2 {
|
||||
domain = parts[1]
|
||||
}
|
||||
}
|
||||
|
||||
if domain == "" {
|
||||
return fmt.Errorf("oidc: no domain found in claims, required domains: %v", p.allowedDomains)
|
||||
}
|
||||
|
||||
for _, allowed := range p.allowedDomains {
|
||||
if strings.EqualFold(domain, allowed) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
return fmt.Errorf("oidc: domain %q not in allowed list %v", domain, p.allowedDomains)
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
// Package idp provides enterprise identity provider integrations for SynapBus.
|
||||
// Supported providers: GitHub (OAuth), Google (OIDC), Azure AD (OIDC).
|
||||
package idp
|
||||
|
||||
import "context"
|
||||
|
||||
// Provider is the interface that all identity providers must implement.
|
||||
type Provider interface {
|
||||
// ID returns the unique identifier for this provider (e.g., "github", "google", "azuread").
|
||||
ID() string
|
||||
// Type returns the provider type ("oauth" or "oidc").
|
||||
Type() string
|
||||
// DisplayName returns the human-readable name (e.g., "GitHub", "Google").
|
||||
DisplayName() string
|
||||
// AuthCodeURL generates the authorization URL with the given state parameter.
|
||||
AuthCodeURL(state string) string
|
||||
// Exchange trades an authorization code for user information.
|
||||
Exchange(ctx context.Context, code string) (*ExternalUser, error)
|
||||
}
|
||||
|
||||
// ExternalUser represents user information obtained from an external identity provider.
|
||||
type ExternalUser struct {
|
||||
ProviderID string
|
||||
ExternalID string
|
||||
Email string
|
||||
Name string
|
||||
Username string
|
||||
Groups []string
|
||||
RawClaims map[string]any
|
||||
}
|
||||
|
||||
// ProviderInfo is a minimal representation of a provider for API responses.
|
||||
type ProviderInfo struct {
|
||||
ID string `json:"id"`
|
||||
Type string `json:"type"`
|
||||
DisplayName string `json:"display_name"`
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package idp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// UserIdentity represents an external identity linked to a local user.
|
||||
type UserIdentity struct {
|
||||
ID int64 `json:"id"`
|
||||
UserID int64 `json:"user_id"`
|
||||
Provider string `json:"provider"`
|
||||
ExternalID string `json:"external_id"`
|
||||
Email string `json:"email,omitempty"`
|
||||
DisplayName string `json:"display_name,omitempty"`
|
||||
RawClaims string `json:"raw_claims"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
// UserIdentityStore manages the user_identities table.
|
||||
type UserIdentityStore struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
// NewUserIdentityStore creates a new identity store backed by SQLite.
|
||||
func NewUserIdentityStore(db *sql.DB) *UserIdentityStore {
|
||||
return &UserIdentityStore{db: db}
|
||||
}
|
||||
|
||||
// FindByProvider looks up a user ID by provider name and external ID.
|
||||
// Returns sql.ErrNoRows if not found.
|
||||
func (s *UserIdentityStore) FindByProvider(ctx context.Context, provider, externalID string) (int64, error) {
|
||||
var userID int64
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT user_id FROM user_identities WHERE provider = ? AND external_id = ?`,
|
||||
provider, externalID,
|
||||
).Scan(&userID)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return userID, nil
|
||||
}
|
||||
|
||||
// Create links an external identity to a local user.
|
||||
func (s *UserIdentityStore) Create(ctx context.Context, userID int64, provider, externalID, email, displayName string, rawClaims map[string]any) error {
|
||||
claimsJSON, err := json.Marshal(rawClaims)
|
||||
if err != nil {
|
||||
claimsJSON = []byte("{}")
|
||||
}
|
||||
|
||||
_, err = s.db.ExecContext(ctx,
|
||||
`INSERT INTO user_identities (user_id, provider, external_id, email, display_name, raw_claims, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`,
|
||||
userID, provider, externalID, email, displayName, string(claimsJSON),
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create identity: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ListByUser returns all external identities linked to a user.
|
||||
func (s *UserIdentityStore) ListByUser(ctx context.Context, userID int64) ([]UserIdentity, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, user_id, provider, external_id, email, display_name, raw_claims, created_at, updated_at
|
||||
FROM user_identities WHERE user_id = ? ORDER BY created_at`,
|
||||
userID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list identities: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var identities []UserIdentity
|
||||
for rows.Next() {
|
||||
var identity UserIdentity
|
||||
var email, displayName sql.NullString
|
||||
if err := rows.Scan(
|
||||
&identity.ID, &identity.UserID, &identity.Provider,
|
||||
&identity.ExternalID, &email, &displayName,
|
||||
&identity.RawClaims, &identity.CreatedAt, &identity.UpdatedAt,
|
||||
); err != nil {
|
||||
return nil, fmt.Errorf("scan identity: %w", err)
|
||||
}
|
||||
identity.Email = email.String
|
||||
identity.DisplayName = displayName.String
|
||||
identities = append(identities, identity)
|
||||
}
|
||||
if identities == nil {
|
||||
identities = []UserIdentity{}
|
||||
}
|
||||
return identities, rows.Err()
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/ory/fosite"
|
||||
)
|
||||
@@ -107,8 +108,11 @@ func RequireBearer(provider fosite.OAuth2Provider, userStore UserStore) func(htt
|
||||
token := parts[1]
|
||||
_ = token
|
||||
|
||||
// Use fosite introspection
|
||||
_, ar, err := provider.IntrospectToken(r.Context(), parts[1], fosite.AccessToken, new(fositeSession))
|
||||
// Use fosite introspection — decouple from HTTP request context so
|
||||
// token validation completes even if the client disconnects.
|
||||
dbCtx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), 10*time.Second)
|
||||
_, ar, err := provider.IntrospectToken(dbCtx, parts[1], fosite.AccessToken, new(fositeSession))
|
||||
cancel()
|
||||
if err != nil {
|
||||
slog.Debug("bearer token validation failed", "error", err)
|
||||
w.Header().Set("WWW-Authenticate", `Bearer error="invalid_token"`)
|
||||
|
||||
@@ -18,10 +18,12 @@ type UserStore interface {
|
||||
CreateUser(ctx context.Context, username, password, displayName string) (*User, error)
|
||||
GetUserByID(ctx context.Context, id int64) (*User, error)
|
||||
GetUserByUsername(ctx context.Context, username string) (*User, error)
|
||||
GetUserByEmail(ctx context.Context, email string) (*User, error)
|
||||
UpdatePassword(ctx context.Context, userID int64, newPassword string) error
|
||||
ListUsers(ctx context.Context) ([]*User, error)
|
||||
CountUsers(ctx context.Context) (int, error)
|
||||
VerifyPassword(ctx context.Context, username, password string) (*User, error)
|
||||
UpdateDisplayName(ctx context.Context, userID int64, displayName string) error
|
||||
}
|
||||
|
||||
// SQLiteUserStore implements UserStore using SQLite.
|
||||
@@ -115,6 +117,36 @@ func (s *SQLiteUserStore) GetUserByID(ctx context.Context, id int64) (*User, err
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// GetUserByEmail retrieves a user by their email address.
|
||||
// Returns ErrUserNotFound if no user has the given email or if email is empty.
|
||||
func (s *SQLiteUserStore) GetUserByEmail(ctx context.Context, email string) (*User, error) {
|
||||
if email == "" {
|
||||
return nil, ErrUserNotFound
|
||||
}
|
||||
user := &User{}
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT id, username, password_hash, display_name, role, created_at, updated_at
|
||||
FROM users WHERE email = ?`, email,
|
||||
).Scan(&user.ID, &user.Username, &user.PasswordHash, &user.DisplayName,
|
||||
&user.Role, &user.CreatedAt, &user.UpdatedAt)
|
||||
if err != nil {
|
||||
if err == sql.ErrNoRows {
|
||||
return nil, ErrUserNotFound
|
||||
}
|
||||
return nil, fmt.Errorf("query user by email: %w", err)
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// SetEmail updates a user's email address.
|
||||
func (s *SQLiteUserStore) SetEmail(ctx context.Context, userID int64, email string) error {
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`UPDATE users SET email = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
|
||||
email, userID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetUserByUsername retrieves a user by their username.
|
||||
func (s *SQLiteUserStore) GetUserByUsername(ctx context.Context, username string) (*User, error) {
|
||||
user := &User{}
|
||||
@@ -215,3 +247,26 @@ func (s *SQLiteUserStore) VerifyPassword(ctx context.Context, username, password
|
||||
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// UpdateDisplayName changes a user's display name.
|
||||
func (s *SQLiteUserStore) UpdateDisplayName(ctx context.Context, userID int64, displayName string) error {
|
||||
displayName = strings.TrimSpace(displayName)
|
||||
if displayName == "" {
|
||||
return fmt.Errorf("display name cannot be empty")
|
||||
}
|
||||
result, err := s.db.ExecContext(ctx,
|
||||
`UPDATE users SET display_name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
|
||||
displayName, userID,
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("update display name: %w", err)
|
||||
}
|
||||
rows, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("check rows affected: %w", err)
|
||||
}
|
||||
if rows == 0 {
|
||||
return ErrUserNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -16,6 +16,7 @@ type ChannelSummary struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
UnreadCount int `json:"unread"`
|
||||
LastMessageID int64 `json:"last_message_id"`
|
||||
LastMessageAt *time.Time `json:"last_message_at"`
|
||||
}
|
||||
|
||||
@@ -311,13 +312,13 @@ func (s *Service) KickFromChannel(ctx context.Context, channelID int64, agentNam
|
||||
|
||||
// ListChannels returns channels visible to the agent.
|
||||
func (s *Service) ListChannels(ctx context.Context, agentName string) ([]*ChannelWithCount, error) {
|
||||
channels, err := s.store.ListChannels(ctx, agentName)
|
||||
chList, err := s.store.ListChannels(ctx, agentName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]*ChannelWithCount, len(channels))
|
||||
for i, ch := range channels {
|
||||
result := make([]*ChannelWithCount, len(chList))
|
||||
for i, ch := range chList {
|
||||
count, err := s.store.CountMembers(ctx, ch.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("count members for channel %d: %w", ch.ID, err)
|
||||
@@ -337,6 +338,63 @@ func (s *Service) ListChannels(ctx context.Context, agentName string) ([]*Channe
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// ListChannelsPaginated returns channels visible to the agent with pagination.
|
||||
func (s *Service) ListChannelsPaginated(ctx context.Context, agentName string, opts ListChannelsOptions) (*PaginatedChannels, error) {
|
||||
allChannels, err := s.store.ListChannels(ctx, agentName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
total := len(allChannels)
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
|
||||
offset := opts.Offset
|
||||
if offset < 0 {
|
||||
offset = 0
|
||||
}
|
||||
|
||||
// Apply pagination
|
||||
start := offset
|
||||
if start > total {
|
||||
start = total
|
||||
}
|
||||
end := start + limit
|
||||
if end > total {
|
||||
end = total
|
||||
}
|
||||
page := allChannels[start:end]
|
||||
|
||||
result := make([]*ChannelWithCount, len(page))
|
||||
for i, ch := range page {
|
||||
count, err := s.store.CountMembers(ctx, ch.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("count members for channel %d: %w", ch.ID, err)
|
||||
}
|
||||
result[i] = &ChannelWithCount{
|
||||
Channel: *ch,
|
||||
MemberCount: count,
|
||||
}
|
||||
}
|
||||
|
||||
if s.tracer != nil {
|
||||
s.tracer.Record(ctx, agentName, "channel.list", map[string]any{
|
||||
"count": len(result),
|
||||
"total": total,
|
||||
})
|
||||
}
|
||||
|
||||
return &PaginatedChannels{
|
||||
Channels: result,
|
||||
Total: total,
|
||||
Offset: offset,
|
||||
Limit: limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetChannel returns a channel by ID.
|
||||
func (s *Service) GetChannel(ctx context.Context, id int64) (*Channel, error) {
|
||||
return s.store.GetChannel(ctx, id)
|
||||
@@ -407,19 +465,24 @@ func (s *Service) UpdateChannel(ctx context.Context, channelID int64, req Update
|
||||
// If the message body contains @mentions, mentioned members receive a
|
||||
// "mention":true flag in their inbox notification metadata, and the channel
|
||||
// message metadata includes "mentioned_agents".
|
||||
func (s *Service) BroadcastMessage(ctx context.Context, channelID int64, fromAgent, body string, priority int, metadata string) ([]*messaging.Message, error) {
|
||||
func (s *Service) BroadcastMessage(ctx context.Context, channelID int64, fromAgent, body string, priority int, metadata string, replyTo *int64) ([]*messaging.Message, error) {
|
||||
ch, err := s.store.GetChannel(ctx, channelID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Verify sender is a member
|
||||
// Verify sender is a member; auto-join public channels on first send.
|
||||
isMember, err := s.store.IsMember(ctx, channelID, fromAgent)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("check membership: %w", err)
|
||||
}
|
||||
if !isMember {
|
||||
return nil, ErrNotChannelMember
|
||||
if ch.IsPrivate {
|
||||
return nil, ErrNotChannelMember
|
||||
}
|
||||
if err := s.JoinChannel(ctx, channelID, fromAgent); err != nil {
|
||||
return nil, fmt.Errorf("auto-join public channel: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Get members for mentions and inbox notifications
|
||||
@@ -463,15 +526,16 @@ func (s *Service) BroadcastMessage(ctx context.Context, channelID int64, fromAge
|
||||
Priority: priority,
|
||||
Metadata: string(channelMetaBytes),
|
||||
ChannelID: &channelID,
|
||||
ReplyTo: replyTo,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create channel message: %w", err)
|
||||
}
|
||||
|
||||
// 2. Deliver inbox notifications to other members.
|
||||
// 2. Deliver inbox notifications only to @mentioned members.
|
||||
recipientCount := 0
|
||||
for _, m := range members {
|
||||
if m.AgentName == fromAgent {
|
||||
if m.AgentName == fromAgent || !mentionedMembers[m.AgentName] {
|
||||
continue
|
||||
}
|
||||
|
||||
@@ -479,12 +543,7 @@ func (s *Service) BroadcastMessage(ctx context.Context, channelID int64, fromAge
|
||||
"channel_id": channelID,
|
||||
"channel_name": ch.Name,
|
||||
"channel_message_id": channelMsg.ID,
|
||||
}
|
||||
if len(mentionedAgentsList) > 0 {
|
||||
inboxMetaObj["mentioned_agents"] = mentionedAgentsList
|
||||
}
|
||||
if mentionedMembers[m.AgentName] {
|
||||
inboxMetaObj["mention"] = true
|
||||
"mention": true,
|
||||
}
|
||||
inboxMetaBytes, _ := json.Marshal(inboxMetaObj)
|
||||
|
||||
@@ -494,7 +553,7 @@ func (s *Service) BroadcastMessage(ctx context.Context, channelID int64, fromAge
|
||||
Metadata: string(inboxMetaBytes),
|
||||
})
|
||||
if err != nil {
|
||||
s.logger.Error("failed to send channel notification",
|
||||
s.logger.Error("failed to send mention notification",
|
||||
"channel_id", channelID,
|
||||
"from", fromAgent,
|
||||
"to", m.AgentName,
|
||||
|
||||
@@ -533,7 +533,7 @@ func TestService_BroadcastMessage(t *testing.T) {
|
||||
ch, _ := svc.CreateChannel(ctx, CreateChannelRequest{Name: "alerts", Type: TypeStandard, CreatedBy: "agent-a"})
|
||||
|
||||
t.Run("broadcast creates channel message", func(t *testing.T) {
|
||||
msgs, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hello", 5, "")
|
||||
msgs, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hello", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
@@ -549,12 +549,12 @@ func TestService_BroadcastMessage(t *testing.T) {
|
||||
})
|
||||
|
||||
t.Run("broadcast visible via GetChannelMessages", func(t *testing.T) {
|
||||
channelMsgs, err := svc.msgService.GetChannelMessages(ctx, ch.ID, 100)
|
||||
channelResult, err := svc.msgService.GetChannelMessages(ctx, ch.ID, 100, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("GetChannelMessages: %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, m := range channelMsgs {
|
||||
for _, m := range channelResult.Messages {
|
||||
if m.Body == "hello" && m.FromAgent == "agent-a" {
|
||||
found = true
|
||||
break
|
||||
@@ -565,44 +565,69 @@ func TestService_BroadcastMessage(t *testing.T) {
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("broadcast delivers inbox notifications", func(t *testing.T) {
|
||||
t.Run("broadcast without mentions sends no DMs", func(t *testing.T) {
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-b")
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-c")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "multi-member test", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "no-dm-test", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
// agent-b should have an inbox notification
|
||||
inbox, _ := svc.msgService.ReadInbox(ctx, "agent-b", messaging.ReadOptions{IncludeRead: true})
|
||||
found := false
|
||||
for _, m := range inbox {
|
||||
if m.Body == "multi-member test" {
|
||||
found = true
|
||||
break
|
||||
// agent-b should NOT have an inbox notification (no @mention)
|
||||
inboxResult, _ := svc.msgService.ReadInbox(ctx, "agent-b", messaging.ReadOptions{IncludeRead: true})
|
||||
for _, m := range inboxResult.Messages {
|
||||
if m.Body == "no-dm-test" {
|
||||
t.Error("agent-b should not receive inbox DM for non-mention broadcast")
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Error("agent-b did not receive inbox notification")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("sender does not receive own message", func(t *testing.T) {
|
||||
svc.BroadcastMessage(ctx, ch.ID, "agent-a", "no self-message", 5, "")
|
||||
inbox, _ := svc.msgService.ReadInbox(ctx, "agent-a", messaging.ReadOptions{IncludeRead: true})
|
||||
for _, m := range inbox {
|
||||
svc.BroadcastMessage(ctx, ch.ID, "agent-a", "no self-message", 5, "", nil)
|
||||
inboxResult, _ := svc.msgService.ReadInbox(ctx, "agent-a", messaging.ReadOptions{IncludeRead: true})
|
||||
for _, m := range inboxResult.Messages {
|
||||
if m.Body == "no self-message" {
|
||||
t.Error("sender should not receive their own broadcast in inbox")
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-member cannot broadcast", func(t *testing.T) {
|
||||
// agent-c is a member but let's test someone who isn't
|
||||
t.Run("non-member auto-joins public channel on broadcast", func(t *testing.T) {
|
||||
seedAgent(t, svc.store.(*SQLiteChannelStore).db, "outsider")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "outsider", "unauthorized", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "outsider", "auto-joined", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("expected auto-join for public channel, got %v", err)
|
||||
}
|
||||
isMember, _ := svc.IsMember(ctx, ch.ID, "outsider")
|
||||
if !isMember {
|
||||
t.Error("outsider should be a member after auto-join")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("broadcast with reply_to", func(t *testing.T) {
|
||||
msgs, _ := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "original", 5, "", nil)
|
||||
original := msgs[0]
|
||||
|
||||
replies, err := svc.BroadcastMessage(ctx, ch.ID, "agent-b", "reply to original", 5, "", &original.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage with reply_to: %v", err)
|
||||
}
|
||||
if replies[0].ReplyTo == nil || *replies[0].ReplyTo != original.ID {
|
||||
t.Errorf("reply_to = %v, want %d", replies[0].ReplyTo, original.ID)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-member cannot broadcast to private channel", func(t *testing.T) {
|
||||
privCh, err := svc.CreateChannel(ctx, CreateChannelRequest{
|
||||
Name: "private-test", Type: TypeStandard, IsPrivate: true, CreatedBy: "agent-a",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("create private channel: %v", err)
|
||||
}
|
||||
seedAgent(t, svc.store.(*SQLiteChannelStore).db, "outsider2")
|
||||
_, err = svc.BroadcastMessage(ctx, privCh.ID, "outsider2", "unauthorized", 5, "", nil)
|
||||
if !errors.Is(err, ErrNotChannelMember) {
|
||||
t.Errorf("expected ErrNotChannelMember, got %v", err)
|
||||
t.Errorf("expected ErrNotChannelMember for private channel, got %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
@@ -619,15 +644,15 @@ func TestService_BroadcastMessage_Mentions(t *testing.T) {
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-c")
|
||||
|
||||
t.Run("mentioned member gets mention flag in inbox", func(t *testing.T) {
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hey @agent-b check this", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hey @agent-b check this", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
// agent-b was mentioned — inbox notification should have mention:true
|
||||
inbox, _ := svc.msgService.ReadInbox(ctx, "agent-b", messaging.ReadOptions{IncludeRead: true})
|
||||
inboxResult, _ := svc.msgService.ReadInbox(ctx, "agent-b", messaging.ReadOptions{IncludeRead: true})
|
||||
found := false
|
||||
for _, m := range inbox {
|
||||
for _, m := range inboxResult.Messages {
|
||||
if m.Body == "hey @agent-b check this" {
|
||||
found = true
|
||||
var meta map[string]any
|
||||
@@ -642,33 +667,24 @@ func TestService_BroadcastMessage_Mentions(t *testing.T) {
|
||||
t.Error("agent-b did not receive inbox notification")
|
||||
}
|
||||
|
||||
// agent-c was NOT mentioned — inbox notification should NOT have mention:true
|
||||
inbox, _ = svc.msgService.ReadInbox(ctx, "agent-c", messaging.ReadOptions{IncludeRead: true})
|
||||
for _, m := range inbox {
|
||||
// agent-c was NOT mentioned — should NOT receive an inbox DM at all
|
||||
inboxResult, _ = svc.msgService.ReadInbox(ctx, "agent-c", messaging.ReadOptions{IncludeRead: true})
|
||||
for _, m := range inboxResult.Messages {
|
||||
if m.Body == "hey @agent-b check this" {
|
||||
var meta map[string]any
|
||||
json.Unmarshal(m.Metadata, &meta)
|
||||
if meta["mention"] == true {
|
||||
t.Error("agent-c should NOT have mention flag")
|
||||
}
|
||||
// But should still have mentioned_agents list
|
||||
if _, ok := meta["mentioned_agents"]; !ok {
|
||||
t.Error("agent-c metadata should have mentioned_agents list")
|
||||
}
|
||||
break
|
||||
t.Error("agent-c should not receive inbox DM when not @mentioned")
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("channel message metadata includes mentioned_agents", func(t *testing.T) {
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "cc @agent-b and @agent-c", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "cc @agent-b and @agent-c", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
channelMsgs, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10)
|
||||
channelResult2, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10, 0)
|
||||
found := false
|
||||
for _, m := range channelMsgs {
|
||||
for _, m := range channelResult2.Messages {
|
||||
if m.Body == "cc @agent-b and @agent-c" {
|
||||
found = true
|
||||
var meta map[string]any
|
||||
@@ -691,13 +707,13 @@ func TestService_BroadcastMessage_Mentions(t *testing.T) {
|
||||
})
|
||||
|
||||
t.Run("self-mention is excluded", func(t *testing.T) {
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "I am @agent-a and cc @agent-b", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "I am @agent-a and cc @agent-b", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
channelMsgs, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10)
|
||||
for _, m := range channelMsgs {
|
||||
channelResult3, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10, 0)
|
||||
for _, m := range channelResult3.Messages {
|
||||
if m.Body == "I am @agent-a and cc @agent-b" {
|
||||
var meta map[string]any
|
||||
json.Unmarshal(m.Metadata, &meta)
|
||||
@@ -716,13 +732,13 @@ func TestService_BroadcastMessage_Mentions(t *testing.T) {
|
||||
})
|
||||
|
||||
t.Run("no mentions produces no mention metadata", func(t *testing.T) {
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "just a normal message", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "just a normal message", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
channelMsgs, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10)
|
||||
for _, m := range channelMsgs {
|
||||
channelResult4, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10, 0)
|
||||
for _, m := range channelResult4.Messages {
|
||||
if m.Body == "just a normal message" {
|
||||
var meta map[string]any
|
||||
json.Unmarshal(m.Metadata, &meta)
|
||||
@@ -736,13 +752,13 @@ func TestService_BroadcastMessage_Mentions(t *testing.T) {
|
||||
|
||||
t.Run("non-member mention is ignored", func(t *testing.T) {
|
||||
seedAgent(t, svc.store.(*SQLiteChannelStore).db, "outsider")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hey @outsider and @agent-b", 5, "")
|
||||
_, err := svc.BroadcastMessage(ctx, ch.ID, "agent-a", "hey @outsider and @agent-b", 5, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("BroadcastMessage: %v", err)
|
||||
}
|
||||
|
||||
channelMsgs, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10)
|
||||
for _, m := range channelMsgs {
|
||||
channelResult5, _ := svc.msgService.GetChannelMessages(ctx, ch.ID, 10, 0)
|
||||
for _, m := range channelResult5.Messages {
|
||||
if m.Body == "hey @outsider and @agent-b" {
|
||||
var meta map[string]any
|
||||
json.Unmarshal(m.Metadata, &meta)
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ChannelStore defines the storage interface for channel operations.
|
||||
@@ -14,6 +15,7 @@ type ChannelStore interface {
|
||||
GetChannel(ctx context.Context, id int64) (*Channel, error)
|
||||
GetChannelByName(ctx context.Context, name string) (*Channel, error)
|
||||
ListChannels(ctx context.Context, agentName string) ([]*Channel, error)
|
||||
CountChannels(ctx context.Context, agentName string) (int, error)
|
||||
UpdateChannel(ctx context.Context, ch *Channel) error
|
||||
DeleteChannel(ctx context.Context, id int64) error
|
||||
AddMember(ctx context.Context, m *Membership) error
|
||||
@@ -148,6 +150,23 @@ func (s *SQLiteChannelStore) ListChannels(ctx context.Context, agentName string)
|
||||
return channels, rows.Err()
|
||||
}
|
||||
|
||||
// CountChannels returns the total number of channels visible to the agent.
|
||||
func (s *SQLiteChannelStore) CountChannels(ctx context.Context, agentName string) (int, error) {
|
||||
var count int
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(DISTINCT c.id)
|
||||
FROM channels c
|
||||
WHERE c.is_private = 0
|
||||
OR EXISTS (SELECT 1 FROM channel_members cm WHERE cm.channel_id = c.id AND cm.agent_name = ?)
|
||||
OR EXISTS (SELECT 1 FROM channel_invites ci WHERE ci.channel_id = c.id AND ci.agent_name = ? AND ci.status = 'pending')`,
|
||||
agentName, agentName,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("count channels: %w", err)
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// UpdateChannel updates a channel's mutable fields.
|
||||
func (s *SQLiteChannelStore) UpdateChannel(ctx context.Context, ch *Channel) error {
|
||||
result, err := s.db.ExecContext(ctx,
|
||||
@@ -362,6 +381,7 @@ func (s *SQLiteChannelStore) GetChannelSummaries(ctx context.Context, agentName
|
||||
WHERE ist.agent_name = ? AND ist.conversation_id = m.conversation_id), 0)
|
||||
AND m.from_agent != ?
|
||||
) AS unread_count,
|
||||
COALESCE((SELECT MAX(m3.id) FROM messages m3 WHERE m3.channel_id = c.id), 0) AS last_message_id,
|
||||
(SELECT MAX(m2.created_at) FROM messages m2 WHERE m2.channel_id = c.id) AS last_message_at
|
||||
FROM channels c
|
||||
JOIN channel_members cm ON cm.channel_id = c.id AND cm.agent_name = ?
|
||||
@@ -376,12 +396,16 @@ func (s *SQLiteChannelStore) GetChannelSummaries(ctx context.Context, agentName
|
||||
var summaries []ChannelSummary
|
||||
for rows.Next() {
|
||||
var cs ChannelSummary
|
||||
var lastMsg sql.NullTime
|
||||
if err := rows.Scan(&cs.ID, &cs.Name, &cs.UnreadCount, &lastMsg); err != nil {
|
||||
var lastMsg sql.NullString
|
||||
if err := rows.Scan(&cs.ID, &cs.Name, &cs.UnreadCount, &cs.LastMessageID, &lastMsg); err != nil {
|
||||
return nil, fmt.Errorf("scan channel summary: %w", err)
|
||||
}
|
||||
if lastMsg.Valid {
|
||||
cs.LastMessageAt = &lastMsg.Time
|
||||
if t, err := time.Parse("2006-01-02T15:04:05Z", lastMsg.String); err == nil {
|
||||
cs.LastMessageAt = &t
|
||||
} else if t, err := time.Parse("2006-01-02 15:04:05", lastMsg.String); err == nil {
|
||||
cs.LastMessageAt = &t
|
||||
}
|
||||
}
|
||||
summaries = append(summaries, cs)
|
||||
}
|
||||
|
||||
@@ -266,6 +266,41 @@ func (s *SwarmService) ListTasks(ctx context.Context, channelID int64, status st
|
||||
return s.taskStore.ListTasks(ctx, channelID, status)
|
||||
}
|
||||
|
||||
// ListTasksPaginated returns tasks for a channel with pagination.
|
||||
func (s *SwarmService) ListTasksPaginated(ctx context.Context, channelID int64, status string, limit, offset int) (*PaginatedTasks, error) {
|
||||
tasks, err := s.taskStore.ListTasks(ctx, channelID, status)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
total := len(tasks)
|
||||
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
if offset < 0 {
|
||||
offset = 0
|
||||
}
|
||||
|
||||
// Apply pagination in memory (task lists are typically small)
|
||||
start := offset
|
||||
if start > total {
|
||||
start = total
|
||||
}
|
||||
end := start + limit
|
||||
if end > total {
|
||||
end = total
|
||||
}
|
||||
page := tasks[start:end]
|
||||
|
||||
return &PaginatedTasks{
|
||||
Tasks: page,
|
||||
Total: total,
|
||||
Offset: offset,
|
||||
Limit: limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetTaskWithBids returns a task and all its bids.
|
||||
func (s *SwarmService) GetTaskWithBids(ctx context.Context, taskID int64) (*Task, []*Bid, error) {
|
||||
task, err := s.taskStore.GetTask(ctx, taskID)
|
||||
|
||||
@@ -14,6 +14,7 @@ type TaskStore interface {
|
||||
CreateTask(ctx context.Context, task *Task) error
|
||||
GetTask(ctx context.Context, id int64) (*Task, error)
|
||||
ListTasks(ctx context.Context, channelID int64, status string) ([]*Task, error)
|
||||
CountTasks(ctx context.Context, channelID int64, status string) (int, error)
|
||||
UpdateTaskStatus(ctx context.Context, id int64, status, assignedTo string) error
|
||||
CreateBid(ctx context.Context, bid *Bid) error
|
||||
GetBids(ctx context.Context, taskID int64) ([]*Bid, error)
|
||||
@@ -130,6 +131,28 @@ func (s *SQLiteTaskStore) ListTasks(ctx context.Context, channelID int64, status
|
||||
return scanTasks(rows)
|
||||
}
|
||||
|
||||
// CountTasks returns the total number of tasks for a channel, optionally filtered by status.
|
||||
func (s *SQLiteTaskStore) CountTasks(ctx context.Context, channelID int64, status string) (int, error) {
|
||||
var count int
|
||||
var err error
|
||||
|
||||
if status != "" {
|
||||
err = s.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM tasks WHERE channel_id = ? AND status = ?`,
|
||||
channelID, status,
|
||||
).Scan(&count)
|
||||
} else {
|
||||
err = s.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM tasks WHERE channel_id = ?`,
|
||||
channelID,
|
||||
).Scan(&count)
|
||||
}
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("count tasks: %w", err)
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// UpdateTaskStatus updates a task's status and optionally assigned_to.
|
||||
func (s *SQLiteTaskStore) UpdateTaskStatus(ctx context.Context, id int64, status, assignedTo string) error {
|
||||
var result sql.Result
|
||||
|
||||
@@ -43,6 +43,28 @@ type ChannelWithCount struct {
|
||||
MemberCount int `json:"member_count"`
|
||||
}
|
||||
|
||||
// PaginatedChannels holds a page of channels with total count.
|
||||
type PaginatedChannels struct {
|
||||
Channels []*ChannelWithCount `json:"channels"`
|
||||
Total int `json:"total"`
|
||||
Offset int `json:"offset"`
|
||||
Limit int `json:"limit"`
|
||||
}
|
||||
|
||||
// ListChannelsOptions configures channel listing behavior.
|
||||
type ListChannelsOptions struct {
|
||||
Limit int `json:"limit,omitempty"`
|
||||
Offset int `json:"offset,omitempty"`
|
||||
}
|
||||
|
||||
// PaginatedTasks holds a page of tasks with total count.
|
||||
type PaginatedTasks struct {
|
||||
Tasks []*Task `json:"tasks"`
|
||||
Total int `json:"total"`
|
||||
Offset int `json:"offset"`
|
||||
Limit int `json:"limit"`
|
||||
}
|
||||
|
||||
// Membership represents the relationship between an agent and a channel.
|
||||
type Membership struct {
|
||||
ID int64 `json:"id"`
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Pool manages a pool of reusable goja VMs for concurrent JavaScript execution.
|
||||
// Each Execute call acquires a VM from the pool, runs the code, then releases
|
||||
// the VM back. If all VMs are in use, callers block until one becomes available
|
||||
// or the context is cancelled.
|
||||
type Pool struct {
|
||||
size int
|
||||
available chan struct{} // semaphore — each token represents a "slot"
|
||||
mu sync.Mutex
|
||||
closed bool
|
||||
}
|
||||
|
||||
// NewPool creates a new runtime pool with the given concurrency limit.
|
||||
// The size determines how many concurrent Execute calls can run simultaneously.
|
||||
func NewPool(size int) *Pool {
|
||||
if size < 1 {
|
||||
size = 1
|
||||
}
|
||||
|
||||
p := &Pool{
|
||||
size: size,
|
||||
available: make(chan struct{}, size),
|
||||
}
|
||||
|
||||
// Fill the semaphore
|
||||
for i := 0; i < size; i++ {
|
||||
p.available <- struct{}{}
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// Execute acquires a slot from the pool, runs the code, and releases the slot.
|
||||
// A fresh goja VM is created for each execution to ensure clean state isolation.
|
||||
// Blocks if all slots are in use; respects context cancellation.
|
||||
func (p *Pool) Execute(ctx context.Context, code string, caller ToolCaller, opts ExecuteOptions) (*ExecuteResult, error) {
|
||||
p.mu.Lock()
|
||||
if p.closed {
|
||||
p.mu.Unlock()
|
||||
return nil, fmt.Errorf("pool is closed")
|
||||
}
|
||||
p.mu.Unlock()
|
||||
|
||||
// Acquire a slot (blocks if pool is exhausted)
|
||||
select {
|
||||
case <-p.available:
|
||||
// Got a slot
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
|
||||
// Always release the slot when done
|
||||
defer func() {
|
||||
p.available <- struct{}{}
|
||||
}()
|
||||
|
||||
// Execute with a fresh VM (created inside Execute)
|
||||
return Execute(ctx, code, caller, opts)
|
||||
}
|
||||
|
||||
// Size returns the configured pool size.
|
||||
func (p *Pool) Size() int {
|
||||
return p.size
|
||||
}
|
||||
|
||||
// Available returns the number of available slots.
|
||||
func (p *Pool) Available() int {
|
||||
return len(p.available)
|
||||
}
|
||||
|
||||
// Close marks the pool as closed. Subsequent Execute calls will return an error.
|
||||
func (p *Pool) Close() {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
p.closed = true
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestNewPool(t *testing.T) {
|
||||
p := NewPool(5)
|
||||
if p.Size() != 5 {
|
||||
t.Errorf("expected size 5, got %d", p.Size())
|
||||
}
|
||||
if p.Available() != 5 {
|
||||
t.Errorf("expected 5 available, got %d", p.Available())
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewPool_MinSize(t *testing.T) {
|
||||
p := NewPool(0)
|
||||
if p.Size() != 1 {
|
||||
t.Errorf("expected size clamped to 1, got %d", p.Size())
|
||||
}
|
||||
|
||||
p2 := NewPool(-5)
|
||||
if p2.Size() != 1 {
|
||||
t.Errorf("expected size clamped to 1, got %d", p2.Size())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPool_Execute(t *testing.T) {
|
||||
p := NewPool(3)
|
||||
defer p.Close()
|
||||
|
||||
caller := newMockCaller()
|
||||
result, err := p.Execute(context.Background(), `42`, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
var num int64
|
||||
switch v := result.Value.(type) {
|
||||
case int64:
|
||||
num = v
|
||||
case float64:
|
||||
num = int64(v)
|
||||
}
|
||||
if num != 42 {
|
||||
t.Errorf("expected 42, got %v", result.Value)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPool_ConcurrentExecution(t *testing.T) {
|
||||
poolSize := 3
|
||||
p := NewPool(poolSize)
|
||||
defer p.Close()
|
||||
|
||||
numGoroutines := 20
|
||||
var wg sync.WaitGroup
|
||||
var successCount int32
|
||||
var errCount int32
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
wg.Add(1)
|
||||
go func(idx int) {
|
||||
defer wg.Done()
|
||||
caller := newMockCaller()
|
||||
result, err := p.Execute(context.Background(), `({ value: 1 })`, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
atomic.AddInt32(&errCount, 1)
|
||||
return
|
||||
}
|
||||
if result != nil {
|
||||
atomic.AddInt32(&successCount, 1)
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
if int(errCount) > 0 {
|
||||
t.Errorf("expected 0 errors, got %d", errCount)
|
||||
}
|
||||
if int(successCount) != numGoroutines {
|
||||
t.Errorf("expected %d successes, got %d", numGoroutines, successCount)
|
||||
}
|
||||
|
||||
// All slots should be available again
|
||||
if p.Available() != poolSize {
|
||||
t.Errorf("expected %d available after all complete, got %d", poolSize, p.Available())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPool_BlocksWhenExhausted(t *testing.T) {
|
||||
p := NewPool(1)
|
||||
defer p.Close()
|
||||
|
||||
// Occupy the only slot with a long-running script
|
||||
started := make(chan struct{})
|
||||
done := make(chan struct{})
|
||||
|
||||
go func() {
|
||||
caller := newMockCaller()
|
||||
close(started)
|
||||
p.Execute(context.Background(), `
|
||||
var i = 0;
|
||||
while(i < 1000000) { i++; }
|
||||
i
|
||||
`, caller, ExecuteOptions{})
|
||||
close(done)
|
||||
}()
|
||||
|
||||
<-started
|
||||
// Give the goroutine a moment to acquire the slot
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
|
||||
// Try to execute with a short timeout — should fail because the slot is occupied
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
|
||||
defer cancel()
|
||||
|
||||
caller := newMockCaller()
|
||||
_, err := p.Execute(ctx, `42`, caller, ExecuteOptions{})
|
||||
|
||||
if err == nil {
|
||||
t.Error("expected context deadline error when pool is exhausted, got nil")
|
||||
}
|
||||
|
||||
// Wait for first execution to finish
|
||||
<-done
|
||||
}
|
||||
|
||||
func TestPool_ClosedPoolRejectsExecute(t *testing.T) {
|
||||
p := NewPool(3)
|
||||
p.Close()
|
||||
|
||||
caller := newMockCaller()
|
||||
_, err := p.Execute(context.Background(), `42`, caller, ExecuteOptions{})
|
||||
if err == nil {
|
||||
t.Error("expected error from closed pool, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPool_WithCallBridge(t *testing.T) {
|
||||
p := NewPool(2)
|
||||
defer p.Close()
|
||||
|
||||
caller := newMockCaller()
|
||||
caller.results["greet"] = map[string]any{"greeting": "hello"}
|
||||
|
||||
code := `
|
||||
var res = call("greet", { name: "world" });
|
||||
res.ok ? res.result.greeting : "error"
|
||||
`
|
||||
|
||||
result, err := p.Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if result.Value != "hello" {
|
||||
t.Errorf("expected 'hello', got %v", result.Value)
|
||||
}
|
||||
if result.CallCount != 1 {
|
||||
t.Errorf("expected CallCount=1, got %d", result.CallCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPool_IsolationBetweenExecutions(t *testing.T) {
|
||||
p := NewPool(1)
|
||||
defer p.Close()
|
||||
|
||||
caller := newMockCaller()
|
||||
|
||||
// First execution sets a variable
|
||||
_, err := p.Execute(context.Background(), `var shared = 42; shared`, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("first execution failed: %v", err)
|
||||
}
|
||||
|
||||
// Second execution should not see the variable from the first
|
||||
_, err = p.Execute(context.Background(), `
|
||||
typeof shared === "undefined" ? "isolated" : "leaked"
|
||||
`, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("second execution failed: %v", err)
|
||||
}
|
||||
// Note: since Execute creates a fresh VM each time, isolation is guaranteed
|
||||
}
|
||||
@@ -0,0 +1,273 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/dop251/goja"
|
||||
)
|
||||
|
||||
// Execute runs JavaScript or TypeScript code in a sandboxed goja VM.
|
||||
//
|
||||
// If the code looks like TypeScript (contains type annotations, interfaces,
|
||||
// generics, etc.), it is automatically transpiled to JavaScript before execution.
|
||||
//
|
||||
// A global `call(actionName, args)` function is provided that bridges to the
|
||||
// supplied ToolCaller. It returns {ok: true, result: ...} or {ok: false, error: ...}.
|
||||
//
|
||||
// The value of the last expression in the code is returned as ExecuteResult.Value.
|
||||
func Execute(ctx context.Context, code string, caller ToolCaller, opts ExecuteOptions) (*ExecuteResult, error) {
|
||||
opts = opts.defaults()
|
||||
start := time.Now()
|
||||
|
||||
// Auto-detect and transpile TypeScript
|
||||
if looksLikeTypeScript(code) {
|
||||
transpiled, err := TranspileTypeScript(code)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
code = transpiled
|
||||
}
|
||||
|
||||
// Handle empty code
|
||||
if len(code) == 0 {
|
||||
return &ExecuteResult{
|
||||
Value: nil,
|
||||
CallCount: 0,
|
||||
Duration: time.Since(start),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Create VM and set up sandbox
|
||||
vm := goja.New()
|
||||
setupSandbox(vm)
|
||||
|
||||
// Track call count
|
||||
var callCount int32
|
||||
|
||||
// Register call() global function
|
||||
callFn := makeCallFunction(ctx, vm, caller, opts.MaxCalls, &callCount)
|
||||
if err := vm.Set("call", callFn); err != nil {
|
||||
return nil, &ExecError{
|
||||
Code: CodeRuntimeError,
|
||||
Message: fmt.Sprintf("failed to register call() function: %v", err),
|
||||
}
|
||||
}
|
||||
|
||||
// Set up timeout via context
|
||||
timeoutCtx, cancel := context.WithTimeout(ctx, opts.Timeout)
|
||||
defer cancel()
|
||||
|
||||
// Run in a goroutine so we can enforce timeout
|
||||
type execResult struct {
|
||||
value goja.Value
|
||||
err error
|
||||
}
|
||||
resultCh := make(chan execResult, 1)
|
||||
|
||||
go func() {
|
||||
// Compile first to get better syntax error reporting
|
||||
prog, compileErr := goja.Compile("", code, false)
|
||||
if compileErr != nil {
|
||||
resultCh <- execResult{err: compileErr}
|
||||
return
|
||||
}
|
||||
val, runErr := vm.RunProgram(prog)
|
||||
resultCh <- execResult{value: val, err: runErr}
|
||||
}()
|
||||
|
||||
// Monitor for timeout — interrupt the VM
|
||||
go func() {
|
||||
<-timeoutCtx.Done()
|
||||
if timeoutCtx.Err() == context.DeadlineExceeded {
|
||||
vm.Interrupt("execution timeout")
|
||||
}
|
||||
}()
|
||||
|
||||
select {
|
||||
case res := <-resultCh:
|
||||
duration := time.Since(start)
|
||||
|
||||
if res.err != nil {
|
||||
return nil, classifyError(res.err)
|
||||
}
|
||||
|
||||
// Export result
|
||||
exported := res.value.Export()
|
||||
|
||||
// Validate JSON serializability
|
||||
if err := validateSerializable(exported); err != nil {
|
||||
return nil, &ExecError{
|
||||
Code: CodeRuntimeError,
|
||||
Message: fmt.Sprintf("result is not JSON-serializable: %v", err),
|
||||
}
|
||||
}
|
||||
|
||||
return &ExecuteResult{
|
||||
Value: exported,
|
||||
CallCount: int(atomic.LoadInt32(&callCount)),
|
||||
Duration: duration,
|
||||
}, nil
|
||||
|
||||
case <-timeoutCtx.Done():
|
||||
vm.Interrupt("execution timeout")
|
||||
return nil, &ExecError{
|
||||
Code: CodeTimeout,
|
||||
Message: fmt.Sprintf("execution exceeded timeout of %s", opts.Timeout),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// setupSandbox disables dangerous global APIs in the VM.
|
||||
func setupSandbox(vm *goja.Runtime) {
|
||||
// Disable module loading
|
||||
vm.Set("require", goja.Undefined())
|
||||
vm.Set("import", goja.Undefined())
|
||||
|
||||
// Disable async operations
|
||||
vm.Set("setTimeout", goja.Undefined())
|
||||
vm.Set("setInterval", goja.Undefined())
|
||||
vm.Set("clearTimeout", goja.Undefined())
|
||||
vm.Set("clearInterval", goja.Undefined())
|
||||
|
||||
// Disable network access
|
||||
vm.Set("fetch", goja.Undefined())
|
||||
vm.Set("XMLHttpRequest", goja.Undefined())
|
||||
|
||||
// Disable process/system access
|
||||
vm.Set("process", goja.Undefined())
|
||||
|
||||
// Note: goja does not provide filesystem or network access by default,
|
||||
// so we only need to block APIs that could be expected by JS code.
|
||||
}
|
||||
|
||||
// makeCallFunction creates the call(actionName, args) bridge function.
|
||||
func makeCallFunction(
|
||||
ctx context.Context,
|
||||
vm *goja.Runtime,
|
||||
caller ToolCaller,
|
||||
maxCalls int,
|
||||
callCount *int32,
|
||||
) func(goja.FunctionCall) goja.Value {
|
||||
return func(fc goja.FunctionCall) goja.Value {
|
||||
// Validate arguments
|
||||
if len(fc.Arguments) < 2 {
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": false,
|
||||
"error": map[string]any{
|
||||
"code": "INVALID_ARGS",
|
||||
"message": "call() requires 2 arguments: actionName (string), args (object)",
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Extract and validate actionName
|
||||
actionName := fc.Arguments[0].String()
|
||||
if actionName == "" || actionName == "undefined" {
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": false,
|
||||
"error": map[string]any{
|
||||
"code": "INVALID_ARGS",
|
||||
"message": "actionName must be a non-empty string",
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Extract and validate args
|
||||
argsExported := fc.Arguments[1].Export()
|
||||
args, ok := argsExported.(map[string]any)
|
||||
if !ok {
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": false,
|
||||
"error": map[string]any{
|
||||
"code": "INVALID_ARGS",
|
||||
"message": "args must be an object",
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Enforce MaxCalls limit
|
||||
count := atomic.AddInt32(callCount, 1)
|
||||
if int(count) > maxCalls {
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": false,
|
||||
"error": map[string]any{
|
||||
"code": CodeMaxCallsExceeded,
|
||||
"message": fmt.Sprintf("exceeded maximum of %d call() invocations", maxCalls),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Bridge to ToolCaller with context propagation
|
||||
result, err := caller.Call(ctx, actionName, args)
|
||||
if err != nil {
|
||||
slog.Warn("call() bridge error",
|
||||
"action", actionName,
|
||||
"error", err,
|
||||
)
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": false,
|
||||
"error": map[string]any{
|
||||
"code": "CALL_ERROR",
|
||||
"message": err.Error(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
return vm.ToValue(map[string]any{
|
||||
"ok": true,
|
||||
"result": result,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// classifyError converts a goja error into a structured ExecError.
|
||||
func classifyError(err error) *ExecError {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Check for interrupt (timeout)
|
||||
if interrupted, ok := err.(*goja.InterruptedError); ok {
|
||||
return &ExecError{
|
||||
Code: CodeTimeout,
|
||||
Message: interrupted.Error(),
|
||||
}
|
||||
}
|
||||
|
||||
// Check for syntax error from compilation
|
||||
if syntaxErr, ok := err.(*goja.CompilerSyntaxError); ok {
|
||||
return &ExecError{
|
||||
Code: CodeSyntaxError,
|
||||
Message: syntaxErr.Error(),
|
||||
}
|
||||
}
|
||||
|
||||
// Check for JS exception (runtime error)
|
||||
if exception, ok := err.(*goja.Exception); ok {
|
||||
return &ExecError{
|
||||
Code: CodeRuntimeError,
|
||||
Message: exception.Error(),
|
||||
Stack: exception.String(),
|
||||
}
|
||||
}
|
||||
|
||||
// Generic error
|
||||
return &ExecError{
|
||||
Code: CodeRuntimeError,
|
||||
Message: err.Error(),
|
||||
}
|
||||
}
|
||||
|
||||
// validateSerializable checks whether the value can be marshaled to JSON.
|
||||
func validateSerializable(value any) error {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
_, err := json.Marshal(value)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,524 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// mockCaller implements ToolCaller for testing.
|
||||
type mockCaller struct {
|
||||
calls []mockCall
|
||||
results map[string]any
|
||||
errors map[string]error
|
||||
}
|
||||
|
||||
type mockCall struct {
|
||||
Action string
|
||||
Args map[string]any
|
||||
}
|
||||
|
||||
func newMockCaller() *mockCaller {
|
||||
return &mockCaller{
|
||||
results: make(map[string]any),
|
||||
errors: make(map[string]error),
|
||||
}
|
||||
}
|
||||
|
||||
func (m *mockCaller) Call(_ context.Context, actionName string, args map[string]any) (any, error) {
|
||||
m.calls = append(m.calls, mockCall{Action: actionName, Args: args})
|
||||
if err, ok := m.errors[actionName]; ok {
|
||||
return nil, err
|
||||
}
|
||||
if result, ok := m.results[actionName]; ok {
|
||||
return result, nil
|
||||
}
|
||||
return map[string]any{"ok": true}, nil
|
||||
}
|
||||
|
||||
func TestExecute(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
opts ExecuteOptions
|
||||
wantValue any
|
||||
wantErr string // substring match on error code
|
||||
}{
|
||||
{
|
||||
name: "simple integer",
|
||||
code: `42`,
|
||||
wantValue: int64(42),
|
||||
},
|
||||
{
|
||||
name: "simple string",
|
||||
code: `"hello"`,
|
||||
wantValue: "hello",
|
||||
},
|
||||
{
|
||||
name: "object literal",
|
||||
code: `({ a: 1, b: "two" })`,
|
||||
},
|
||||
{
|
||||
name: "arithmetic expression",
|
||||
code: `2 + 3 * 4`,
|
||||
},
|
||||
{
|
||||
name: "null value",
|
||||
code: `null`,
|
||||
wantValue: nil,
|
||||
},
|
||||
{
|
||||
name: "array",
|
||||
code: `[1, 2, 3]`,
|
||||
},
|
||||
{
|
||||
name: "boolean true",
|
||||
code: `true`,
|
||||
wantValue: true,
|
||||
},
|
||||
{
|
||||
name: "boolean false",
|
||||
code: `false`,
|
||||
wantValue: false,
|
||||
},
|
||||
{
|
||||
name: "empty code",
|
||||
code: "",
|
||||
wantValue: nil,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
result, err := Execute(context.Background(), tt.code, caller, tt.opts)
|
||||
|
||||
if tt.wantErr != "" {
|
||||
if err == nil {
|
||||
t.Fatalf("expected error containing %q, got nil", tt.wantErr)
|
||||
}
|
||||
execErr, ok := err.(*ExecError)
|
||||
if !ok {
|
||||
t.Fatalf("expected *ExecError, got %T: %v", err, err)
|
||||
}
|
||||
if execErr.Code != tt.wantErr {
|
||||
t.Errorf("expected error code %q, got %q", tt.wantErr, execErr.Code)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if tt.wantValue != nil && result.Value != tt.wantValue {
|
||||
t.Errorf("expected value %v (%T), got %v (%T)", tt.wantValue, tt.wantValue, result.Value, result.Value)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_SyntaxError(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
_, err := Execute(context.Background(), `{ invalid syntax`, caller, ExecuteOptions{})
|
||||
|
||||
if err == nil {
|
||||
t.Fatal("expected syntax error, got nil")
|
||||
}
|
||||
execErr, ok := err.(*ExecError)
|
||||
if !ok {
|
||||
t.Fatalf("expected *ExecError, got %T", err)
|
||||
}
|
||||
if execErr.Code != CodeSyntaxError {
|
||||
t.Errorf("expected code %q, got %q", CodeSyntaxError, execErr.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_RuntimeError(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
_, err := Execute(context.Background(), `throw new Error("boom")`, caller, ExecuteOptions{})
|
||||
|
||||
if err == nil {
|
||||
t.Fatal("expected runtime error, got nil")
|
||||
}
|
||||
execErr, ok := err.(*ExecError)
|
||||
if !ok {
|
||||
t.Fatalf("expected *ExecError, got %T", err)
|
||||
}
|
||||
if execErr.Code != CodeRuntimeError {
|
||||
t.Errorf("expected code %q, got %q", CodeRuntimeError, execErr.Code)
|
||||
}
|
||||
if execErr.Stack == "" {
|
||||
t.Error("expected non-empty stack trace for runtime error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_Timeout(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
start := time.Now()
|
||||
_, err := Execute(context.Background(), `while(true) {}`, caller, ExecuteOptions{
|
||||
Timeout: 100 * time.Millisecond,
|
||||
})
|
||||
elapsed := time.Since(start)
|
||||
|
||||
if err == nil {
|
||||
t.Fatal("expected timeout error, got nil")
|
||||
}
|
||||
execErr, ok := err.(*ExecError)
|
||||
if !ok {
|
||||
t.Fatalf("expected *ExecError, got %T", err)
|
||||
}
|
||||
if execErr.Code != CodeTimeout {
|
||||
t.Errorf("expected code %q, got %q", CodeTimeout, execErr.Code)
|
||||
}
|
||||
|
||||
// Should complete within a reasonable margin of the timeout
|
||||
if elapsed > 2*time.Second {
|
||||
t.Errorf("timeout took too long: %v", elapsed)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_CallBridge(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
caller.results["get_user"] = map[string]any{
|
||||
"name": "alice",
|
||||
"id": 42,
|
||||
}
|
||||
|
||||
code := `
|
||||
var res = call("get_user", { id: 1 });
|
||||
if (!res.ok) throw new Error("failed");
|
||||
({ name: res.result.name })
|
||||
`
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if len(caller.calls) != 1 {
|
||||
t.Fatalf("expected 1 call, got %d", len(caller.calls))
|
||||
}
|
||||
if caller.calls[0].Action != "get_user" {
|
||||
t.Errorf("expected action 'get_user', got %q", caller.calls[0].Action)
|
||||
}
|
||||
if result.CallCount != 1 {
|
||||
t.Errorf("expected CallCount=1, got %d", result.CallCount)
|
||||
}
|
||||
|
||||
resultMap, ok := result.Value.(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected map result, got %T", result.Value)
|
||||
}
|
||||
if resultMap["name"] != "alice" {
|
||||
t.Errorf("expected name='alice', got %v", resultMap["name"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_CallBridgeError(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
caller.errors["fail_action"] = fmt.Errorf("upstream error")
|
||||
|
||||
code := `
|
||||
var res = call("fail_action", {});
|
||||
({ ok: res.ok, code: res.error.code })
|
||||
`
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
resultMap := result.Value.(map[string]any)
|
||||
if resultMap["ok"] != false {
|
||||
t.Errorf("expected ok=false, got %v", resultMap["ok"])
|
||||
}
|
||||
if resultMap["code"] != "CALL_ERROR" {
|
||||
t.Errorf("expected code='CALL_ERROR', got %v", resultMap["code"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_CallInvalidArgs(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
}{
|
||||
{"no arguments", `call()`},
|
||||
{"one argument", `call("action")`},
|
||||
{"args not object", `call("action", "not_an_object")`},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
code := fmt.Sprintf(`
|
||||
var res = %s;
|
||||
({ ok: res.ok, code: res.error.code })
|
||||
`, tt.code)
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
resultMap := result.Value.(map[string]any)
|
||||
if resultMap["ok"] != false {
|
||||
t.Errorf("expected ok=false, got %v", resultMap["ok"])
|
||||
}
|
||||
if resultMap["code"] != "INVALID_ARGS" {
|
||||
t.Errorf("expected code='INVALID_ARGS', got %v", resultMap["code"])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_MaxCalls(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
caller.results["action"] = "ok"
|
||||
|
||||
code := `
|
||||
var results = [];
|
||||
for (var i = 0; i < 10; i++) {
|
||||
var res = call("action", {});
|
||||
results.push({ ok: res.ok, code: res.error ? res.error.code : null });
|
||||
}
|
||||
({ results: results, total: results.length })
|
||||
`
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{
|
||||
MaxCalls: 3,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
// Only 3 calls should have succeeded upstream
|
||||
if len(caller.calls) != 3 {
|
||||
t.Errorf("expected 3 upstream calls, got %d", len(caller.calls))
|
||||
}
|
||||
|
||||
resultMap := result.Value.(map[string]any)
|
||||
results := resultMap["results"].([]any)
|
||||
|
||||
// First 3 should be ok, rest should be MAX_CALLS_EXCEEDED
|
||||
for i, r := range results {
|
||||
rm := r.(map[string]any)
|
||||
if i < 3 {
|
||||
if rm["ok"] != true {
|
||||
t.Errorf("call %d: expected ok=true, got %v", i, rm["ok"])
|
||||
}
|
||||
} else {
|
||||
if rm["ok"] != false {
|
||||
t.Errorf("call %d: expected ok=false, got %v", i, rm["ok"])
|
||||
}
|
||||
if rm["code"] != CodeMaxCallsExceeded {
|
||||
t.Errorf("call %d: expected code=%q, got %v", i, CodeMaxCallsExceeded, rm["code"])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_MultipleCallsInLoop(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
caller.results["add"] = map[string]any{"sum": 10}
|
||||
|
||||
code := `
|
||||
var total = 0;
|
||||
for (var i = 0; i < 5; i++) {
|
||||
var res = call("add", { a: i, b: 1 });
|
||||
if (res.ok) total++;
|
||||
}
|
||||
({ total: total })
|
||||
`
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if len(caller.calls) != 5 {
|
||||
t.Fatalf("expected 5 calls, got %d", len(caller.calls))
|
||||
}
|
||||
if result.CallCount != 5 {
|
||||
t.Errorf("expected CallCount=5, got %d", result.CallCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_SandboxBlockedAPIs(t *testing.T) {
|
||||
blockedAPIs := []struct {
|
||||
name string
|
||||
code string
|
||||
}{
|
||||
{"require", `require("fs")`},
|
||||
{"fetch", `fetch("http://example.com")`},
|
||||
{"setTimeout", `setTimeout(function(){}, 100)`},
|
||||
{"setInterval", `setInterval(function(){}, 100)`},
|
||||
{"clearTimeout", `clearTimeout(1)`},
|
||||
{"clearInterval", `clearInterval(1)`},
|
||||
{"XMLHttpRequest", `new XMLHttpRequest()`},
|
||||
{"process.env", `process.env.HOME`},
|
||||
}
|
||||
|
||||
for _, tt := range blockedAPIs {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
result, err := Execute(context.Background(), tt.code, caller, ExecuteOptions{})
|
||||
|
||||
// Should either error or return undefined (not execute the blocked API)
|
||||
if err == nil && result.Ok() {
|
||||
// If it succeeds, the value should be undefined/nil (the API was replaced with undefined)
|
||||
// This is acceptable — the key thing is the API doesn't actually work
|
||||
t.Logf("%s returned: %v (blocked by sandbox)", tt.name, result.Value)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Ok is a helper for test assertions.
|
||||
func (r *ExecuteResult) Ok() bool {
|
||||
return r != nil
|
||||
}
|
||||
|
||||
func TestExecute_TypeScriptAutoDetect(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
code := `const x: number = 42; const msg: string = "hello"; ({ result: x, message: msg })`
|
||||
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
resultMap, ok := result.Value.(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected map, got %T", result.Value)
|
||||
}
|
||||
|
||||
// goja exports numbers as int64 or float64
|
||||
var num int64
|
||||
switch v := resultMap["result"].(type) {
|
||||
case int64:
|
||||
num = v
|
||||
case float64:
|
||||
num = int64(v)
|
||||
default:
|
||||
t.Fatalf("expected numeric result, got %T", resultMap["result"])
|
||||
}
|
||||
if num != 42 {
|
||||
t.Errorf("expected 42, got %d", num)
|
||||
}
|
||||
if resultMap["message"] != "hello" {
|
||||
t.Errorf("expected 'hello', got %v", resultMap["message"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_TypeScriptWithInterface(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
caller.results["get_data"] = map[string]any{"value": 99}
|
||||
|
||||
code := `
|
||||
interface Result {
|
||||
ok: boolean;
|
||||
result?: any;
|
||||
error?: any;
|
||||
}
|
||||
const res: Result = call("get_data", { key: "test" });
|
||||
if (!res.ok) throw new Error("failed");
|
||||
({ data: res.result })
|
||||
`
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if len(caller.calls) != 1 {
|
||||
t.Fatalf("expected 1 call, got %d", len(caller.calls))
|
||||
}
|
||||
|
||||
resultMap := result.Value.(map[string]any)
|
||||
data := resultMap["data"].(map[string]any)
|
||||
// Values passed through the call() bridge preserve their Go types
|
||||
var val int64
|
||||
switch v := data["value"].(type) {
|
||||
case int:
|
||||
val = int64(v)
|
||||
case int64:
|
||||
val = v
|
||||
case float64:
|
||||
val = int64(v)
|
||||
}
|
||||
if val != 99 {
|
||||
t.Errorf("expected value=99, got %v", data["value"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_PlainJSNotTranspiled(t *testing.T) {
|
||||
// Plain JS should work without transpilation
|
||||
caller := newMockCaller()
|
||||
code := `var x = 42; x`
|
||||
|
||||
result, err := Execute(context.Background(), code, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
var num int64
|
||||
switch v := result.Value.(type) {
|
||||
case int64:
|
||||
num = v
|
||||
case float64:
|
||||
num = int64(v)
|
||||
}
|
||||
if num != 42 {
|
||||
t.Errorf("expected 42, got %v", result.Value)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_Duration(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
result, err := Execute(context.Background(), `42`, caller, ExecuteOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if result.Duration <= 0 {
|
||||
t.Error("expected positive duration")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecute_ContextCancellation(t *testing.T) {
|
||||
caller := newMockCaller()
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel() // Cancel immediately
|
||||
|
||||
_, err := Execute(ctx, `while(true) {}`, caller, ExecuteOptions{
|
||||
Timeout: 5 * time.Second,
|
||||
})
|
||||
|
||||
if err == nil {
|
||||
t.Fatal("expected error from cancelled context")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecError_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
err ExecError
|
||||
contains string
|
||||
}{
|
||||
{
|
||||
name: "without stack",
|
||||
err: ExecError{Code: CodeSyntaxError, Message: "unexpected token"},
|
||||
contains: "SYNTAX_ERROR: unexpected token",
|
||||
},
|
||||
{
|
||||
name: "with stack",
|
||||
err: ExecError{Code: CodeRuntimeError, Message: "boom", Stack: "at line 1"},
|
||||
contains: "at line 1",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
msg := tt.err.Error()
|
||||
if msg == "" {
|
||||
t.Error("expected non-empty error message")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ToolCaller is implemented by the action registry to bridge call() invocations
|
||||
// from JavaScript code to the host application.
|
||||
type ToolCaller interface {
|
||||
Call(ctx context.Context, actionName string, args map[string]any) (any, error)
|
||||
}
|
||||
|
||||
// ExecuteOptions configures a single code execution.
|
||||
type ExecuteOptions struct {
|
||||
Timeout time.Duration // Maximum execution time. Default 120s.
|
||||
MaxCalls int // Maximum number of call() invocations. Default 50.
|
||||
MaxMemoryMB int // Memory limit hint in MB. Default 128.
|
||||
}
|
||||
|
||||
// defaults fills in zero-value fields with sensible defaults.
|
||||
func (o ExecuteOptions) defaults() ExecuteOptions {
|
||||
if o.Timeout <= 0 {
|
||||
o.Timeout = 120 * time.Second
|
||||
}
|
||||
if o.MaxCalls <= 0 {
|
||||
o.MaxCalls = 50
|
||||
}
|
||||
if o.MaxMemoryMB <= 0 {
|
||||
o.MaxMemoryMB = 128
|
||||
}
|
||||
return o
|
||||
}
|
||||
|
||||
// ExecuteResult holds the output of a successful execution.
|
||||
type ExecuteResult struct {
|
||||
Value any // Final expression value (JSON-serializable)
|
||||
CallCount int // Number of call() invocations made
|
||||
Duration time.Duration // Wall-clock execution time
|
||||
}
|
||||
|
||||
// ExecError wraps execution errors with structured context.
|
||||
type ExecError struct {
|
||||
Code string // SYNTAX_ERROR, RUNTIME_ERROR, TIMEOUT, MAX_CALLS_EXCEEDED, TRANSPILE_ERROR
|
||||
Message string // Human-readable error description
|
||||
Stack string // JS stack trace if available
|
||||
Line int // Source line if available
|
||||
Column int // Source column if available
|
||||
}
|
||||
|
||||
// Error implements the error interface.
|
||||
func (e *ExecError) Error() string {
|
||||
if e.Stack != "" {
|
||||
return fmt.Sprintf("%s: %s\n%s", e.Code, e.Message, e.Stack)
|
||||
}
|
||||
return fmt.Sprintf("%s: %s", e.Code, e.Message)
|
||||
}
|
||||
|
||||
// Error code constants.
|
||||
const (
|
||||
CodeSyntaxError = "SYNTAX_ERROR"
|
||||
CodeRuntimeError = "RUNTIME_ERROR"
|
||||
CodeTimeout = "TIMEOUT"
|
||||
CodeMaxCallsExceeded = "MAX_CALLS_EXCEEDED"
|
||||
CodeTranspileError = "TRANSPILE_ERROR"
|
||||
)
|
||||
@@ -0,0 +1,78 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/evanw/esbuild/pkg/api"
|
||||
)
|
||||
|
||||
// TranspileTypeScript transpiles TypeScript code to JavaScript using esbuild.
|
||||
// It performs type-stripping only (no bundling, no type checking).
|
||||
// Target is ES2020 for compatibility with goja.
|
||||
func TranspileTypeScript(code string) (string, error) {
|
||||
result := api.Transform(code, api.TransformOptions{
|
||||
Loader: api.LoaderTS,
|
||||
Target: api.ES2020,
|
||||
})
|
||||
|
||||
if len(result.Errors) > 0 {
|
||||
msg := result.Errors[0]
|
||||
e := &ExecError{
|
||||
Code: CodeTranspileError,
|
||||
Message: fmt.Sprintf("TypeScript transpilation failed: %s", msg.Text),
|
||||
}
|
||||
if msg.Location != nil {
|
||||
e.Line = msg.Location.Line
|
||||
e.Column = msg.Location.Column
|
||||
e.Message = fmt.Sprintf("TypeScript transpilation failed at line %d, column %d: %s",
|
||||
msg.Location.Line, msg.Location.Column, msg.Text)
|
||||
}
|
||||
return "", e
|
||||
}
|
||||
|
||||
return string(result.Code), nil
|
||||
}
|
||||
|
||||
// looksLikeTypeScript uses simple heuristics to detect TypeScript code.
|
||||
// It checks for common TypeScript-only syntax patterns.
|
||||
func looksLikeTypeScript(code string) bool {
|
||||
// Check for type annotations like `: string`, `: number`, `: boolean`, `: any`
|
||||
typeAnnotationPatterns := []string{
|
||||
": string",
|
||||
": number",
|
||||
": boolean",
|
||||
": any",
|
||||
": void",
|
||||
": never",
|
||||
": unknown",
|
||||
}
|
||||
for _, pattern := range typeAnnotationPatterns {
|
||||
if strings.Contains(code, pattern) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// Check for interface declarations
|
||||
if strings.Contains(code, "interface ") && strings.Contains(code, "{") {
|
||||
return true
|
||||
}
|
||||
|
||||
// Check for type aliases
|
||||
if strings.Contains(code, "type ") && strings.Contains(code, "=") {
|
||||
return true
|
||||
}
|
||||
|
||||
// Check for generic type parameters like <T> or <T,U>
|
||||
// Simple heuristic: look for <identifier> patterns not preceded by comparison operators
|
||||
if strings.Contains(code, "<T>") || strings.Contains(code, "<T,") || strings.Contains(code, "<T ") {
|
||||
return true
|
||||
}
|
||||
|
||||
// Check for 'as' type assertions
|
||||
if strings.Contains(code, " as ") {
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
package jsruntime
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTranspileTypeScript(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
wantContain string // substring that must be in the output
|
||||
wantAbsent string // substring that must NOT be in the output
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "basic type annotation",
|
||||
code: `const x: number = 42; x;`,
|
||||
wantContain: "42",
|
||||
wantAbsent: ": number",
|
||||
},
|
||||
{
|
||||
name: "interface removed",
|
||||
code: "interface User { name: string; age: number; }\nconst u: User = { name: \"Alice\", age: 30 }; u;",
|
||||
wantContain: "Alice",
|
||||
wantAbsent: "interface",
|
||||
},
|
||||
{
|
||||
name: "generics stripped",
|
||||
code: "function identity<T>(arg: T): T { return arg; }\nconst r = identity<number>(42); r;",
|
||||
wantContain: "42",
|
||||
wantAbsent: "<T>",
|
||||
},
|
||||
{
|
||||
name: "enum produces JS",
|
||||
code: "enum Dir { Up = \"UP\", Down = \"DOWN\" }\nconst d: Dir = Dir.Up; d;",
|
||||
wantContain: "UP",
|
||||
wantAbsent: ": Dir",
|
||||
},
|
||||
{
|
||||
name: "type alias removed",
|
||||
code: "type ID = string | number;\nconst id: ID = \"abc\"; id;",
|
||||
wantContain: "abc",
|
||||
wantAbsent: "type ID",
|
||||
},
|
||||
{
|
||||
name: "as expression stripped",
|
||||
code: `const x = (42 as number); x;`,
|
||||
wantContain: "42",
|
||||
},
|
||||
{
|
||||
name: "plain JS passthrough",
|
||||
code: `var x = 42; x;`,
|
||||
wantContain: "42",
|
||||
},
|
||||
{
|
||||
name: "empty code",
|
||||
code: "",
|
||||
wantContain: "",
|
||||
},
|
||||
{
|
||||
name: "invalid code",
|
||||
code: `const x: number = ;`,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result, err := TranspileTypeScript(tt.code)
|
||||
|
||||
if tt.wantErr {
|
||||
if err == nil {
|
||||
t.Fatal("expected error, got nil")
|
||||
}
|
||||
execErr, ok := err.(*ExecError)
|
||||
if !ok {
|
||||
t.Fatalf("expected *ExecError, got %T", err)
|
||||
}
|
||||
if execErr.Code != CodeTranspileError {
|
||||
t.Errorf("expected code %q, got %q", CodeTranspileError, execErr.Code)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if tt.wantContain != "" && !strings.Contains(result, tt.wantContain) {
|
||||
t.Errorf("output should contain %q, got: %s", tt.wantContain, result)
|
||||
}
|
||||
|
||||
if tt.wantAbsent != "" && strings.Contains(result, tt.wantAbsent) {
|
||||
t.Errorf("output should NOT contain %q, got: %s", tt.wantAbsent, result)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTranspileTypeScript_ErrorDetails(t *testing.T) {
|
||||
_, err := TranspileTypeScript(`const x: number = ;`)
|
||||
if err == nil {
|
||||
t.Fatal("expected error")
|
||||
}
|
||||
|
||||
execErr := err.(*ExecError)
|
||||
|
||||
// Should include line info
|
||||
if execErr.Line == 0 && execErr.Column == 0 {
|
||||
// esbuild may or may not provide location for all errors;
|
||||
// at minimum the message should be informative
|
||||
if execErr.Message == "" {
|
||||
t.Error("expected non-empty error message")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLooksLikeTypeScript(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
want bool
|
||||
}{
|
||||
{"plain JS", `var x = 42;`, false},
|
||||
{"type annotation string", `const x: string = "hi";`, true},
|
||||
{"type annotation number", `const x: number = 1;`, true},
|
||||
{"type annotation boolean", `const x: boolean = true;`, true},
|
||||
{"type annotation any", `const x: any = null;`, true},
|
||||
{"interface", `interface Foo { bar: string; }`, true},
|
||||
{"type alias", `type ID = string`, true},
|
||||
{"generic T", `function id<T>(x: T): T { return x; }`, true},
|
||||
{"as expression", `const x = 42 as number;`, true},
|
||||
{"no false positive on colon in object", `var x = { a: 1, b: 2 };`, false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := looksLikeTypeScript(tt.code)
|
||||
if got != tt.want {
|
||||
t.Errorf("looksLikeTypeScript(%q) = %v, want %v", tt.code, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,947 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
)
|
||||
|
||||
// ServiceBridge implements jsruntime.ToolCaller, mapping action names to
|
||||
// service method calls. It carries the authenticated agent's identity.
|
||||
type ServiceBridge struct {
|
||||
msgService *messaging.MessagingService
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
swarmService *channels.SwarmService
|
||||
attachmentService *attachments.Service
|
||||
searchService *search.Service
|
||||
agentName string
|
||||
}
|
||||
|
||||
// NewServiceBridge creates a new bridge for the given authenticated agent.
|
||||
func NewServiceBridge(
|
||||
msgService *messaging.MessagingService,
|
||||
agentService *agents.AgentService,
|
||||
channelService *channels.Service,
|
||||
swarmService *channels.SwarmService,
|
||||
attachmentService *attachments.Service,
|
||||
searchService *search.Service,
|
||||
agentName string,
|
||||
) *ServiceBridge {
|
||||
return &ServiceBridge{
|
||||
msgService: msgService,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
swarmService: swarmService,
|
||||
attachmentService: attachmentService,
|
||||
searchService: searchService,
|
||||
agentName: agentName,
|
||||
}
|
||||
}
|
||||
|
||||
// Call dispatches an action by name to the appropriate service method.
|
||||
func (b *ServiceBridge) Call(ctx context.Context, actionName string, args map[string]any) (any, error) {
|
||||
switch actionName {
|
||||
// --- Messaging ---
|
||||
case "read_inbox":
|
||||
return b.callReadInbox(ctx, args)
|
||||
case "claim_messages":
|
||||
return b.callClaimMessages(ctx, args)
|
||||
case "mark_done":
|
||||
return b.callMarkDone(ctx, args)
|
||||
case "search_messages":
|
||||
return b.callSearchMessages(ctx, args)
|
||||
case "discover_agents":
|
||||
return b.callDiscoverAgents(ctx, args)
|
||||
|
||||
// --- Channels ---
|
||||
case "create_channel":
|
||||
return b.callCreateChannel(ctx, args)
|
||||
case "join_channel":
|
||||
return b.callJoinChannel(ctx, args)
|
||||
case "leave_channel":
|
||||
return b.callLeaveChannel(ctx, args)
|
||||
case "list_channels":
|
||||
return b.callListChannels(ctx, args)
|
||||
case "invite_to_channel":
|
||||
return b.callInviteToChannel(ctx, args)
|
||||
case "kick_from_channel":
|
||||
return b.callKickFromChannel(ctx, args)
|
||||
case "get_channel_messages":
|
||||
return b.callGetChannelMessages(ctx, args)
|
||||
case "send_channel_message":
|
||||
return b.callSendChannelMessage(ctx, args)
|
||||
case "update_channel":
|
||||
return b.callUpdateChannel(ctx, args)
|
||||
|
||||
// --- Swarm ---
|
||||
case "post_task":
|
||||
return b.callPostTask(ctx, args)
|
||||
case "bid_task":
|
||||
return b.callBidTask(ctx, args)
|
||||
case "accept_bid":
|
||||
return b.callAcceptBid(ctx, args)
|
||||
case "complete_task":
|
||||
return b.callCompleteTask(ctx, args)
|
||||
case "list_tasks":
|
||||
return b.callListTasks(ctx, args)
|
||||
|
||||
// --- Attachments ---
|
||||
case "upload_attachment":
|
||||
return b.callUploadAttachment(ctx, args)
|
||||
case "download_attachment":
|
||||
return b.callDownloadAttachment(ctx, args)
|
||||
|
||||
// --- DM send (also accessible via bridge for execute tool) ---
|
||||
case "send_message":
|
||||
return b.callSendMessage(ctx, args)
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("unknown action: %s", actionName)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Messaging implementations ---
|
||||
|
||||
func (b *ServiceBridge) callSendMessage(ctx context.Context, args map[string]any) (any, error) {
|
||||
to := getString(args, "to", "")
|
||||
body := getString(args, "body", "")
|
||||
if body == "" {
|
||||
return nil, fmt.Errorf("'body' parameter is required")
|
||||
}
|
||||
|
||||
var channelID *int64
|
||||
if cid := getInt(args, "channel_id", 0); cid > 0 {
|
||||
v := int64(cid)
|
||||
channelID = &v
|
||||
}
|
||||
|
||||
var replyTo *int64
|
||||
if rtID := getInt(args, "reply_to", 0); rtID > 0 {
|
||||
v := int64(rtID)
|
||||
replyTo = &v
|
||||
}
|
||||
|
||||
opts := messaging.SendOptions{
|
||||
Subject: getString(args, "subject", ""),
|
||||
Priority: getInt(args, "priority", 5),
|
||||
Metadata: getString(args, "metadata", ""),
|
||||
ChannelID: channelID,
|
||||
ReplyTo: replyTo,
|
||||
}
|
||||
|
||||
msg, err := b.msgService.SendMessage(ctx, b.agentName, to, body, opts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"message_id": msg.ID,
|
||||
"conversation_id": msg.ConversationID,
|
||||
"status": msg.Status,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callReadInbox(ctx context.Context, args map[string]any) (any, error) {
|
||||
opts := messaging.ReadOptions{
|
||||
Limit: getInt(args, "limit", 50),
|
||||
Status: getString(args, "status_filter", ""),
|
||||
MinPriority: getInt(args, "min_priority", 0),
|
||||
FromAgent: getString(args, "from_agent", ""),
|
||||
IncludeRead: getBool(args, "include_read", false),
|
||||
}
|
||||
|
||||
page, err := b.msgService.ReadInbox(ctx, b.agentName, opts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"messages": page.Messages,
|
||||
"count": len(page.Messages),
|
||||
"total": page.Total,
|
||||
"offset": page.Offset,
|
||||
"limit": page.Limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callClaimMessages(ctx context.Context, args map[string]any) (any, error) {
|
||||
limit := getInt(args, "limit", 10)
|
||||
|
||||
messages, err := b.msgService.ClaimMessages(ctx, b.agentName, limit)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"messages": messages,
|
||||
"count": len(messages),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callMarkDone(ctx context.Context, args map[string]any) (any, error) {
|
||||
messageID := getInt(args, "message_id", 0)
|
||||
if messageID == 0 {
|
||||
return nil, fmt.Errorf("'message_id' parameter is required")
|
||||
}
|
||||
|
||||
status := getString(args, "status", "done")
|
||||
reason := getString(args, "reason", "")
|
||||
|
||||
switch status {
|
||||
case "done":
|
||||
if err := b.msgService.MarkDone(ctx, int64(messageID), b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
case "failed":
|
||||
if err := b.msgService.MarkFailed(ctx, int64(messageID), b.agentName, reason); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
return nil, fmt.Errorf("status must be 'done' or 'failed'")
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"message_id": messageID,
|
||||
"status": status,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callSearchMessages(ctx context.Context, args map[string]any) (any, error) {
|
||||
query := getString(args, "query", "")
|
||||
|
||||
// If search service is available, use it for unified search.
|
||||
if b.searchService != nil {
|
||||
searchMode := getString(args, "search_mode", "auto")
|
||||
|
||||
opts := search.SearchOptions{
|
||||
Query: query,
|
||||
Mode: searchMode,
|
||||
Limit: getInt(args, "limit", 10),
|
||||
FromAgent: getString(args, "from_agent", ""),
|
||||
MinPriority: getInt(args, "min_priority", 0),
|
||||
}
|
||||
|
||||
resp, err := b.searchService.Search(ctx, b.agentName, opts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
resultMsgs := make([]map[string]any, len(resp.Results))
|
||||
for i, r := range resp.Results {
|
||||
entry := map[string]any{
|
||||
"message": r.Message,
|
||||
"match_type": r.MatchType,
|
||||
}
|
||||
if r.SimilarityScore > 0 {
|
||||
entry["similarity_score"] = r.SimilarityScore
|
||||
}
|
||||
if r.RelevanceScore > 0 {
|
||||
entry["relevance_score"] = r.RelevanceScore
|
||||
}
|
||||
resultMsgs[i] = entry
|
||||
}
|
||||
|
||||
result := map[string]any{
|
||||
"results": resultMsgs,
|
||||
"count": resp.TotalResults,
|
||||
"search_mode": resp.SearchMode,
|
||||
}
|
||||
if resp.Warning != "" {
|
||||
result["warning"] = resp.Warning
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// Fallback: FTS only.
|
||||
msgOpts := messaging.SearchOptions{
|
||||
Limit: getInt(args, "limit", 20),
|
||||
MinPriority: getInt(args, "min_priority", 0),
|
||||
FromAgent: getString(args, "from_agent", ""),
|
||||
Status: getString(args, "status", ""),
|
||||
}
|
||||
|
||||
page, err := b.msgService.SearchMessages(ctx, b.agentName, query, msgOpts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"messages": page.Messages,
|
||||
"count": len(page.Messages),
|
||||
"total": page.Total,
|
||||
"offset": page.Offset,
|
||||
"limit": page.Limit,
|
||||
"search_mode": "fulltext",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callDiscoverAgents(ctx context.Context, args map[string]any) (any, error) {
|
||||
query := getString(args, "query", "")
|
||||
|
||||
agentsList, err := b.agentService.DiscoverAgents(ctx, query)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]map[string]any, 0, len(agentsList))
|
||||
for _, a := range agentsList {
|
||||
if a.Name == "system" {
|
||||
continue
|
||||
}
|
||||
result = append(result, map[string]any{
|
||||
"name": a.Name,
|
||||
"display_name": a.DisplayName,
|
||||
"type": a.Type,
|
||||
"capabilities": a.Capabilities,
|
||||
"status": a.Status,
|
||||
})
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"agents": result,
|
||||
"count": len(result),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// --- Channel implementations ---
|
||||
|
||||
func (b *ServiceBridge) callCreateChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
name := getString(args, "name", "")
|
||||
if name == "" {
|
||||
return nil, fmt.Errorf("'name' parameter is required")
|
||||
}
|
||||
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
createReq := channels.CreateChannelRequest{
|
||||
Name: name,
|
||||
Description: getString(args, "description", ""),
|
||||
Topic: getString(args, "topic", ""),
|
||||
Type: getString(args, "type", "standard"),
|
||||
IsPrivate: getBool(args, "is_private", false),
|
||||
CreatedBy: b.agentName,
|
||||
}
|
||||
|
||||
ch, err := b.channelService.CreateChannel(ctx, createReq)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
"type": ch.Type,
|
||||
"is_private": ch.IsPrivate,
|
||||
"created_by": ch.CreatedBy,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callJoinChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := b.channelService.JoinChannel(ctx, channelID, b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"status": "joined",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callLeaveChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := b.channelService.LeaveChannel(ctx, channelID, b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"status": "left",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callListChannels(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
chList, err := b.channelService.ListChannels(ctx, b.agentName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(chList))
|
||||
for i, ch := range chList {
|
||||
result[i] = map[string]any{
|
||||
"id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
"type": ch.Type,
|
||||
"is_private": ch.IsPrivate,
|
||||
"created_by": ch.CreatedBy,
|
||||
"member_count": ch.MemberCount,
|
||||
}
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channels": result,
|
||||
"count": len(result),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callInviteToChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
targetAgent := getString(args, "agent_name", "")
|
||||
if targetAgent == "" {
|
||||
return nil, fmt.Errorf("'agent_name' parameter is required")
|
||||
}
|
||||
|
||||
if err := b.channelService.InviteToChannel(ctx, channelID, targetAgent, b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"agent_name": targetAgent,
|
||||
"status": "invited",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callKickFromChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
targetAgent := getString(args, "agent_name", "")
|
||||
if targetAgent == "" {
|
||||
return nil, fmt.Errorf("'agent_name' parameter is required")
|
||||
}
|
||||
|
||||
if err := b.channelService.KickFromChannel(ctx, channelID, targetAgent, b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"agent_name": targetAgent,
|
||||
"status": "kicked",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callGetChannelMessages(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Verify membership.
|
||||
isMember, err := b.channelService.IsMember(ctx, channelID, b.agentName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !isMember {
|
||||
return nil, fmt.Errorf("you are not a member of this channel")
|
||||
}
|
||||
|
||||
limit := getInt(args, "limit", 50)
|
||||
if limit > 200 {
|
||||
limit = 200
|
||||
}
|
||||
|
||||
offset := getInt(args, "offset", 0)
|
||||
page, err := b.msgService.GetChannelMessages(ctx, channelID, limit, offset)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(page.Messages))
|
||||
for i, msg := range page.Messages {
|
||||
result[i] = map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": msg.Body,
|
||||
"priority": msg.Priority,
|
||||
"status": msg.Status,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
if len(msg.Metadata) > 0 {
|
||||
result[i]["metadata"] = msg.Metadata
|
||||
}
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"messages": result,
|
||||
"count": len(result),
|
||||
"total": page.Total,
|
||||
"offset": page.Offset,
|
||||
"limit": page.Limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callSendChannelMessage(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
body := getString(args, "body", "")
|
||||
if body == "" {
|
||||
return nil, fmt.Errorf("'body' parameter is required")
|
||||
}
|
||||
|
||||
priority := getInt(args, "priority", 5)
|
||||
metadata := getString(args, "metadata", "")
|
||||
|
||||
var replyTo *int64
|
||||
if v, ok := args["reply_to"]; ok {
|
||||
if f, ok := v.(float64); ok {
|
||||
r := int64(f)
|
||||
replyTo = &r
|
||||
}
|
||||
}
|
||||
|
||||
messages, err := b.channelService.BroadcastMessage(ctx, channelID, b.agentName, body, priority, metadata, replyTo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var messageID int64
|
||||
if len(messages) > 0 {
|
||||
messageID = messages[0].ID
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": channelID,
|
||||
"message_id": messageID,
|
||||
"status": "sent",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callUpdateChannel(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelID, err := b.resolveChannelID(ctx, args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
updateReq := channels.UpdateChannelRequest{}
|
||||
if v, ok := args["topic"]; ok {
|
||||
if s, ok := v.(string); ok {
|
||||
updateReq.Topic = &s
|
||||
}
|
||||
}
|
||||
if v, ok := args["description"]; ok {
|
||||
if s, ok := v.(string); ok {
|
||||
updateReq.Description = &s
|
||||
}
|
||||
}
|
||||
|
||||
ch, err := b.channelService.UpdateChannel(ctx, channelID, updateReq, b.agentName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"channel_id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// --- Swarm implementations ---
|
||||
|
||||
func (b *ServiceBridge) callPostTask(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.swarmService == nil {
|
||||
return nil, fmt.Errorf("swarm service not available")
|
||||
}
|
||||
|
||||
channelName := getString(args, "channel_name", "")
|
||||
if channelName == "" {
|
||||
return nil, fmt.Errorf("'channel_name' parameter is required")
|
||||
}
|
||||
|
||||
title := getString(args, "title", "")
|
||||
if title == "" {
|
||||
return nil, fmt.Errorf("'title' parameter is required")
|
||||
}
|
||||
|
||||
description := getString(args, "description", "")
|
||||
requirementsStr := getString(args, "requirements", "{}")
|
||||
deadlineStr := getString(args, "deadline", "")
|
||||
|
||||
var requirements json.RawMessage
|
||||
if requirementsStr != "" {
|
||||
if !json.Valid([]byte(requirementsStr)) {
|
||||
return nil, fmt.Errorf("requirements must be valid JSON")
|
||||
}
|
||||
requirements = json.RawMessage(requirementsStr)
|
||||
}
|
||||
|
||||
var deadline *time.Time
|
||||
if deadlineStr != "" {
|
||||
t, err := time.Parse(time.RFC3339, deadlineStr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("deadline must be ISO 8601 format: %s", err)
|
||||
}
|
||||
deadline = &t
|
||||
}
|
||||
|
||||
ch, err := b.channelService.GetChannelByName(ctx, channelName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
task, err := b.swarmService.PostTask(ctx, ch.ID, b.agentName, title, description, requirements, deadline)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"task_id": task.ID,
|
||||
"channel_id": task.ChannelID,
|
||||
"title": task.Title,
|
||||
"status": task.Status,
|
||||
"posted_by": task.PostedBy,
|
||||
"deadline": task.Deadline,
|
||||
"created_at": task.CreatedAt,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callBidTask(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.swarmService == nil {
|
||||
return nil, fmt.Errorf("swarm service not available")
|
||||
}
|
||||
|
||||
taskID := getInt(args, "task_id", 0)
|
||||
if taskID == 0 {
|
||||
return nil, fmt.Errorf("'task_id' parameter is required")
|
||||
}
|
||||
|
||||
capabilitiesStr := getString(args, "capabilities", "{}")
|
||||
timeEstimate := getString(args, "time_estimate", "")
|
||||
message := getString(args, "message", "")
|
||||
|
||||
var capabilities json.RawMessage
|
||||
if capabilitiesStr != "" {
|
||||
if !json.Valid([]byte(capabilitiesStr)) {
|
||||
return nil, fmt.Errorf("capabilities must be valid JSON")
|
||||
}
|
||||
capabilities = json.RawMessage(capabilitiesStr)
|
||||
}
|
||||
|
||||
bid, err := b.swarmService.BidOnTask(ctx, int64(taskID), b.agentName, capabilities, timeEstimate, message)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"bid_id": bid.ID,
|
||||
"task_id": bid.TaskID,
|
||||
"agent_name": bid.AgentName,
|
||||
"time_estimate": bid.TimeEstimate,
|
||||
"status": bid.Status,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callAcceptBid(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.swarmService == nil {
|
||||
return nil, fmt.Errorf("swarm service not available")
|
||||
}
|
||||
|
||||
taskID := getInt(args, "task_id", 0)
|
||||
if taskID == 0 {
|
||||
return nil, fmt.Errorf("'task_id' parameter is required")
|
||||
}
|
||||
|
||||
bidID := getInt(args, "bid_id", 0)
|
||||
if bidID == 0 {
|
||||
return nil, fmt.Errorf("'bid_id' parameter is required")
|
||||
}
|
||||
|
||||
if err := b.swarmService.AcceptBid(ctx, int64(taskID), int64(bidID), b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"task_id": taskID,
|
||||
"bid_id": bidID,
|
||||
"status": "accepted",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callCompleteTask(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.swarmService == nil {
|
||||
return nil, fmt.Errorf("swarm service not available")
|
||||
}
|
||||
|
||||
taskID := getInt(args, "task_id", 0)
|
||||
if taskID == 0 {
|
||||
return nil, fmt.Errorf("'task_id' parameter is required")
|
||||
}
|
||||
|
||||
if err := b.swarmService.CompleteTask(ctx, int64(taskID), b.agentName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"task_id": taskID,
|
||||
"status": "completed",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callListTasks(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.swarmService == nil {
|
||||
return nil, fmt.Errorf("swarm service not available")
|
||||
}
|
||||
if b.channelService == nil {
|
||||
return nil, fmt.Errorf("channel service not available")
|
||||
}
|
||||
|
||||
channelName := getString(args, "channel_name", "")
|
||||
if channelName == "" {
|
||||
return nil, fmt.Errorf("'channel_name' parameter is required")
|
||||
}
|
||||
|
||||
statusFilter := getString(args, "status", "")
|
||||
|
||||
ch, err := b.channelService.GetChannelByName(ctx, channelName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if ch.Type != channels.TypeAuction {
|
||||
return nil, fmt.Errorf("list_tasks requires a channel of type 'auction', got '%s'", ch.Type)
|
||||
}
|
||||
|
||||
tasks, err := b.swarmService.ListTasks(ctx, ch.ID, statusFilter)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(tasks))
|
||||
for i, task := range tasks {
|
||||
result[i] = map[string]any{
|
||||
"id": task.ID,
|
||||
"title": task.Title,
|
||||
"description": task.Description,
|
||||
"status": task.Status,
|
||||
"posted_by": task.PostedBy,
|
||||
"assigned_to": task.AssignedTo,
|
||||
"deadline": task.Deadline,
|
||||
"created_at": task.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"tasks": result,
|
||||
"count": len(result),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// --- Attachment implementations ---
|
||||
|
||||
func (b *ServiceBridge) callUploadAttachment(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.attachmentService == nil {
|
||||
return nil, fmt.Errorf("attachment service not available")
|
||||
}
|
||||
|
||||
contentB64 := getString(args, "content", "")
|
||||
if contentB64 == "" {
|
||||
return nil, fmt.Errorf("'content' parameter is required")
|
||||
}
|
||||
|
||||
if int64(len(contentB64))*3/4 > attachments.MaxFileSize {
|
||||
return nil, fmt.Errorf("file exceeds maximum size of 50MB")
|
||||
}
|
||||
|
||||
decoded, err := base64.StdEncoding.DecodeString(contentB64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid base64 content: %s", err)
|
||||
}
|
||||
|
||||
if int64(len(decoded)) > attachments.MaxFileSize {
|
||||
return nil, fmt.Errorf("file exceeds maximum size of 50MB")
|
||||
}
|
||||
|
||||
uploadReq := attachments.UploadRequest{
|
||||
Content: bytes.NewReader(decoded),
|
||||
Filename: getString(args, "filename", ""),
|
||||
MIMEType: getString(args, "mime_type", ""),
|
||||
UploadedBy: b.agentName,
|
||||
}
|
||||
|
||||
if mid := getInt(args, "message_id", 0); mid > 0 {
|
||||
v := int64(mid)
|
||||
uploadReq.MessageID = &v
|
||||
}
|
||||
|
||||
uploadResult, err := b.attachmentService.Upload(ctx, uploadReq)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"hash": uploadResult.Hash,
|
||||
"size": uploadResult.Size,
|
||||
"mime_type": uploadResult.MIMEType,
|
||||
"original_filename": uploadResult.Filename,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (b *ServiceBridge) callDownloadAttachment(ctx context.Context, args map[string]any) (any, error) {
|
||||
if b.attachmentService == nil {
|
||||
return nil, fmt.Errorf("attachment service not available")
|
||||
}
|
||||
|
||||
hash := getString(args, "hash", "")
|
||||
if hash == "" {
|
||||
return nil, fmt.Errorf("'hash' parameter is required")
|
||||
}
|
||||
|
||||
dlResult, err := b.attachmentService.Download(ctx, hash)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer dlResult.Content.Close()
|
||||
|
||||
content, err := io.ReadAll(dlResult.Content)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read attachment content: %s", err)
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"hash": dlResult.Hash,
|
||||
"content": base64.StdEncoding.EncodeToString(content),
|
||||
"original_filename": dlResult.Filename,
|
||||
"mime_type": dlResult.MIMEType,
|
||||
"size": dlResult.Size,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// --- Helpers ---
|
||||
|
||||
// resolveChannelID resolves a channel ID from either channel_id or channel_name in args.
|
||||
func (b *ServiceBridge) resolveChannelID(ctx context.Context, args map[string]any) (int64, error) {
|
||||
if cid := getInt(args, "channel_id", 0); cid > 0 {
|
||||
return int64(cid), nil
|
||||
}
|
||||
|
||||
name := getString(args, "channel_name", "")
|
||||
if name != "" {
|
||||
ch, err := b.channelService.GetChannelByName(ctx, name)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return ch.ID, nil
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("either 'channel_id' or 'channel_name' is required")
|
||||
}
|
||||
|
||||
// getString extracts a string value from args with a default.
|
||||
func getString(args map[string]any, key, defaultVal string) string {
|
||||
v, ok := args[key]
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
s, ok := v.(string)
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// getInt extracts an int value from args with a default.
|
||||
// Handles both int and float64 (JSON numbers decode as float64).
|
||||
func getInt(args map[string]any, key string, defaultVal int) int {
|
||||
v, ok := args[key]
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
switch n := v.(type) {
|
||||
case int:
|
||||
return n
|
||||
case int64:
|
||||
return int(n)
|
||||
case float64:
|
||||
return int(n)
|
||||
case json.Number:
|
||||
i, err := n.Int64()
|
||||
if err != nil {
|
||||
return defaultVal
|
||||
}
|
||||
return int(i)
|
||||
}
|
||||
return defaultVal
|
||||
}
|
||||
|
||||
// getBool extracts a bool value from args with a default.
|
||||
func getBool(args map[string]any, key string, defaultVal bool) bool {
|
||||
v, ok := args[key]
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
b, ok := v.(bool)
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
return b
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
func newTestBridge(t *testing.T) (*ServiceBridge, *messaging.MessagingService, *agents.AgentService, *channels.Service) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
tracer := trace.NewTracer(db)
|
||||
t.Cleanup(func() { tracer.Close() })
|
||||
|
||||
msgStore := messaging.NewSQLiteMessageStore(db)
|
||||
msgService := messaging.NewMessagingService(msgStore, tracer)
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
channelStore := channels.NewSQLiteChannelStore(db)
|
||||
channelService := channels.NewService(channelStore, msgService, tracer)
|
||||
|
||||
taskStore := channels.NewSQLiteTaskStore(db)
|
||||
swarmService := channels.NewSwarmService(taskStore, channelStore, tracer)
|
||||
|
||||
// Seed test agents
|
||||
agentService.Register(context.Background(), "agent-a", "Agent A", "ai", nil, 1)
|
||||
agentService.Register(context.Background(), "agent-b", "Agent B", "ai", nil, 1)
|
||||
|
||||
bridge := NewServiceBridge(
|
||||
msgService,
|
||||
agentService,
|
||||
channelService,
|
||||
swarmService,
|
||||
nil, // attachmentService
|
||||
nil, // searchService
|
||||
"agent-a",
|
||||
)
|
||||
return bridge, msgService, agentService, channelService
|
||||
}
|
||||
|
||||
func TestBridge_SendMessage(t *testing.T) {
|
||||
bridge, _, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
result, err := bridge.Call(ctx, "send_message", map[string]any{
|
||||
"to": "agent-b",
|
||||
"body": "hello from bridge",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call send_message: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["message_id"] == nil {
|
||||
t.Error("expected message_id")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_ReadInbox(t *testing.T) {
|
||||
bridge, msgService, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Send a message to agent-a
|
||||
msgService.SendMessage(ctx, "agent-b", "agent-a", "test inbox msg", messaging.SendOptions{})
|
||||
|
||||
result, err := bridge.Call(ctx, "read_inbox", map[string]any{
|
||||
"limit": 10,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call read_inbox: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["count"].(int) != 1 {
|
||||
t.Errorf("count = %v, want 1", r["count"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_ClaimMessages(t *testing.T) {
|
||||
bridge, msgService, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
msgService.SendMessage(ctx, "agent-b", "agent-a", "claim me", messaging.SendOptions{})
|
||||
|
||||
result, err := bridge.Call(ctx, "claim_messages", map[string]any{
|
||||
"limit": 1,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call claim_messages: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
count := r["count"].(int)
|
||||
if count != 1 {
|
||||
t.Errorf("count = %v, want 1", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_MarkDone(t *testing.T) {
|
||||
bridge, msgService, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
msg, _ := msgService.SendMessage(ctx, "agent-b", "agent-a", "done me", messaging.SendOptions{})
|
||||
msgService.ClaimMessages(ctx, "agent-a", 1)
|
||||
|
||||
result, err := bridge.Call(ctx, "mark_done", map[string]any{
|
||||
"message_id": int(msg.ID),
|
||||
"status": "done",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call mark_done: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["status"] != "done" {
|
||||
t.Errorf("status = %v, want done", r["status"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_MarkDone_Missing(t *testing.T) {
|
||||
bridge, _, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
_, err := bridge.Call(ctx, "mark_done", map[string]any{})
|
||||
if err == nil {
|
||||
t.Error("expected error for missing message_id")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_DiscoverAgents(t *testing.T) {
|
||||
bridge, _, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
result, err := bridge.Call(ctx, "discover_agents", map[string]any{})
|
||||
if err != nil {
|
||||
t.Fatalf("Call discover_agents: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
count := r["count"].(int)
|
||||
if count < 2 {
|
||||
t.Errorf("expected at least 2 agents, got %v", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_CreateChannel(t *testing.T) {
|
||||
bridge, _, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
result, err := bridge.Call(ctx, "create_channel", map[string]any{
|
||||
"name": "bridge-test-ch",
|
||||
"type": "standard",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call create_channel: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["name"] != "bridge-test-ch" {
|
||||
t.Errorf("name = %v, want bridge-test-ch", r["name"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_JoinChannel(t *testing.T) {
|
||||
bridge, _, _, channelService := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "join-bridge", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
// Create a bridge for agent-b to join
|
||||
bridgeB := NewServiceBridge(
|
||||
bridge.msgService,
|
||||
bridge.agentService,
|
||||
bridge.channelService,
|
||||
bridge.swarmService,
|
||||
nil, nil,
|
||||
"agent-b",
|
||||
)
|
||||
|
||||
result, err := bridgeB.Call(ctx, "join_channel", map[string]any{
|
||||
"channel_name": "join-bridge",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call join_channel: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["status"] != "joined" {
|
||||
t.Errorf("status = %v, want joined", r["status"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_ListChannels(t *testing.T) {
|
||||
bridge, _, _, channelService := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "list-ch-1", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "list-ch-2", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
result, err := bridge.Call(ctx, "list_channels", map[string]any{})
|
||||
if err != nil {
|
||||
t.Fatalf("Call list_channels: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
count := r["count"].(int)
|
||||
if count < 2 {
|
||||
t.Errorf("expected at least 2 channels, got %v", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_SendChannelMessage(t *testing.T) {
|
||||
bridge, _, _, channelService := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "msg-bridge", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
result, err := bridge.Call(ctx, "send_channel_message", map[string]any{
|
||||
"channel_name": "msg-bridge",
|
||||
"body": "hello from bridge",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Call send_channel_message: %v", err)
|
||||
}
|
||||
|
||||
r := result.(map[string]any)
|
||||
if r["status"] != "sent" {
|
||||
t.Errorf("status = %v, want sent", r["status"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_UnknownAction(t *testing.T) {
|
||||
bridge, _, _, _ := newTestBridge(t)
|
||||
ctx := context.Background()
|
||||
|
||||
_, err := bridge.Call(ctx, "totally_unknown", map[string]any{})
|
||||
if err == nil {
|
||||
t.Error("expected error for unknown action")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBridge_ParamHelpers(t *testing.T) {
|
||||
args := map[string]any{
|
||||
"str_val": "hello",
|
||||
"int_val": float64(42),
|
||||
"bool_val": true,
|
||||
"nil_val": nil,
|
||||
}
|
||||
|
||||
t.Run("getString", func(t *testing.T) {
|
||||
if v := getString(args, "str_val", ""); v != "hello" {
|
||||
t.Errorf("got %q, want hello", v)
|
||||
}
|
||||
if v := getString(args, "missing", "default"); v != "default" {
|
||||
t.Errorf("got %q, want default", v)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("getInt", func(t *testing.T) {
|
||||
if v := getInt(args, "int_val", 0); v != 42 {
|
||||
t.Errorf("got %d, want 42", v)
|
||||
}
|
||||
if v := getInt(args, "missing", 99); v != 99 {
|
||||
t.Errorf("got %d, want 99", v)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("getBool", func(t *testing.T) {
|
||||
if v := getBool(args, "bool_val", false); v != true {
|
||||
t.Errorf("got %v, want true", v)
|
||||
}
|
||||
if v := getBool(args, "missing", true); v != true {
|
||||
t.Errorf("got %v, want true", v)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
var _ = storage.RunMigrations
|
||||
@@ -1,438 +0,0 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
)
|
||||
|
||||
// ChannelToolRegistrar registers channel MCP tools on the server.
|
||||
type ChannelToolRegistrar struct {
|
||||
channelService *channels.Service
|
||||
msgService *messaging.MessagingService
|
||||
}
|
||||
|
||||
// NewChannelToolRegistrar creates a new channel tool registrar.
|
||||
func NewChannelToolRegistrar(channelService *channels.Service, msgService *messaging.MessagingService) *ChannelToolRegistrar {
|
||||
return &ChannelToolRegistrar{
|
||||
channelService: channelService,
|
||||
msgService: msgService,
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAll registers all channel tools on the MCP server.
|
||||
func (ctr *ChannelToolRegistrar) RegisterAll(s *server.MCPServer) {
|
||||
s.AddTool(ctr.createChannelTool(), ctr.handleCreateChannel)
|
||||
s.AddTool(ctr.joinChannelTool(), ctr.handleJoinChannel)
|
||||
s.AddTool(ctr.leaveChannelTool(), ctr.handleLeaveChannel)
|
||||
s.AddTool(ctr.listChannelsTool(), ctr.handleListChannels)
|
||||
s.AddTool(ctr.inviteToChannelTool(), ctr.handleInviteToChannel)
|
||||
s.AddTool(ctr.kickFromChannelTool(), ctr.handleKickFromChannel)
|
||||
s.AddTool(ctr.getChannelMessagesTool(), ctr.handleGetChannelMessages)
|
||||
s.AddTool(ctr.sendChannelMessageTool(), ctr.handleSendChannelMessage)
|
||||
s.AddTool(ctr.updateChannelTool(), ctr.handleUpdateChannel)
|
||||
}
|
||||
|
||||
// --- Tool Definitions ---
|
||||
|
||||
func (ctr *ChannelToolRegistrar) createChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("create_channel",
|
||||
mcp.WithDescription("Create a new channel for group communication"),
|
||||
mcp.WithString("name", mcp.Description("Unique channel name (alphanumeric, hyphens, underscores, max 64 chars)"), mcp.Required()),
|
||||
mcp.WithString("description", mcp.Description("Channel description")),
|
||||
mcp.WithString("topic", mcp.Description("Current channel topic")),
|
||||
mcp.WithString("type", mcp.Description("Channel type: 'standard', 'blackboard', or 'auction' (default 'standard')")),
|
||||
mcp.WithBoolean("is_private", mcp.Description("Whether the channel is private (invite-only). Default false")),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) joinChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("join_channel",
|
||||
mcp.WithDescription("Join a channel to participate in group conversations. You will receive messages sent to the channel after joining. Use list_channels first to see available channels."),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel to join")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel to join (alternative to channel_id)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) leaveChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("leave_channel",
|
||||
mcp.WithDescription("Leave a channel you are a member of"),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel to leave")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel to leave (alternative to channel_id)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) listChannelsTool() mcp.Tool {
|
||||
return mcp.NewTool("list_channels",
|
||||
mcp.WithDescription("List all channels visible to you. Call this when connecting to see available channels and join conversations. Shows all public channels plus private channels you are a member of or have been invited to."),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) inviteToChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("invite_to_channel",
|
||||
mcp.WithDescription("Invite an agent to a channel (only the channel owner can invite to private channels)"),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel (alternative to channel_id)")),
|
||||
mcp.WithString("agent_name", mcp.Description("Name of the agent to invite"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) kickFromChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("kick_from_channel",
|
||||
mcp.WithDescription("Remove an agent from a channel (only the channel owner can kick)"),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel (alternative to channel_id)")),
|
||||
mcp.WithString("agent_name", mcp.Description("Name of the agent to kick"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) getChannelMessagesTool() mcp.Tool {
|
||||
return mcp.NewTool("get_channel_messages",
|
||||
mcp.WithDescription("Get recent messages from a channel you are a member of"),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel (alternative to channel_id)")),
|
||||
mcp.WithNumber("limit", mcp.Description("Max number of messages to return (default 50, max 200)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) sendChannelMessageTool() mcp.Tool {
|
||||
return mcp.NewTool("send_channel_message",
|
||||
mcp.WithDescription("Send a message to all members of a channel. Use @agentname in the body to mention specific agents. You must be a member of the channel to send messages."),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel (alternative to channel_id)")),
|
||||
mcp.WithString("body", mcp.Description("Message body text"), mcp.Required()),
|
||||
mcp.WithNumber("priority", mcp.Description("Message priority (1-10, default 5)"), mcp.Min(1), mcp.Max(10)),
|
||||
mcp.WithString("metadata", mcp.Description("JSON metadata object (optional)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) updateChannelTool() mcp.Tool {
|
||||
return mcp.NewTool("update_channel",
|
||||
mcp.WithDescription("Update channel topic or description (only the channel owner can update)"),
|
||||
mcp.WithNumber("channel_id", mcp.Description("ID of the channel")),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the channel (alternative to channel_id)")),
|
||||
mcp.WithString("topic", mcp.Description("New channel topic")),
|
||||
mcp.WithString("description", mcp.Description("New channel description")),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Tool Handlers ---
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleCreateChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
name := req.GetString("name", "")
|
||||
if name == "" {
|
||||
return mcp.NewToolResultError("'name' parameter is required"), nil
|
||||
}
|
||||
|
||||
isPrivate := false
|
||||
args := req.GetArguments()
|
||||
if v, ok := args["is_private"]; ok {
|
||||
if b, ok := v.(bool); ok {
|
||||
isPrivate = b
|
||||
}
|
||||
}
|
||||
|
||||
createReq := channels.CreateChannelRequest{
|
||||
Name: name,
|
||||
Description: req.GetString("description", ""),
|
||||
Topic: req.GetString("topic", ""),
|
||||
Type: req.GetString("type", "standard"),
|
||||
IsPrivate: isPrivate,
|
||||
CreatedBy: agentName,
|
||||
}
|
||||
|
||||
ch, err := ctr.channelService.CreateChannel(ctx, createReq)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("create_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
"type": ch.Type,
|
||||
"is_private": ch.IsPrivate,
|
||||
"created_by": ch.CreatedBy,
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleJoinChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("join_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
if err := ctr.channelService.JoinChannel(ctx, channelID, agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("join_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"status": "joined",
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleLeaveChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("leave_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
if err := ctr.channelService.LeaveChannel(ctx, channelID, agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("leave_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"status": "left",
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleListChannels(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
chList, err := ctr.channelService.ListChannels(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_channels failed: %s", err)), nil
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(chList))
|
||||
for i, ch := range chList {
|
||||
result[i] = map[string]any{
|
||||
"id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
"type": ch.Type,
|
||||
"is_private": ch.IsPrivate,
|
||||
"created_by": ch.CreatedBy,
|
||||
"member_count": ch.MemberCount,
|
||||
}
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channels": result,
|
||||
"count": len(result),
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleInviteToChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("invite_to_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
targetAgent := req.GetString("agent_name", "")
|
||||
if targetAgent == "" {
|
||||
return mcp.NewToolResultError("'agent_name' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := ctr.channelService.InviteToChannel(ctx, channelID, targetAgent, agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("invite_to_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"agent_name": targetAgent,
|
||||
"status": "invited",
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleKickFromChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("kick_from_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
targetAgent := req.GetString("agent_name", "")
|
||||
if targetAgent == "" {
|
||||
return mcp.NewToolResultError("'agent_name' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := ctr.channelService.KickFromChannel(ctx, channelID, targetAgent, agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("kick_from_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"agent_name": targetAgent,
|
||||
"status": "kicked",
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleGetChannelMessages(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("get_channel_messages failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Verify the agent is a member of the channel
|
||||
isMember, err := ctr.channelService.IsMember(ctx, channelID, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("get_channel_messages failed: %s", err)), nil
|
||||
}
|
||||
if !isMember {
|
||||
return mcp.NewToolResultError("you are not a member of this channel"), nil
|
||||
}
|
||||
|
||||
limit := req.GetInt("limit", 50)
|
||||
if limit > 200 {
|
||||
limit = 200
|
||||
}
|
||||
|
||||
messages, err := ctr.msgService.GetChannelMessages(ctx, channelID, limit)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("get_channel_messages failed: %s", err)), nil
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(messages))
|
||||
for i, msg := range messages {
|
||||
result[i] = map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": msg.Body,
|
||||
"priority": msg.Priority,
|
||||
"status": msg.Status,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
if len(msg.Metadata) > 0 {
|
||||
result[i]["metadata"] = msg.Metadata
|
||||
}
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"messages": result,
|
||||
"count": len(result),
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleSendChannelMessage(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("send_channel_message failed: %s", err)), nil
|
||||
}
|
||||
|
||||
body := req.GetString("body", "")
|
||||
if body == "" {
|
||||
return mcp.NewToolResultError("'body' parameter is required"), nil
|
||||
}
|
||||
|
||||
priority := req.GetInt("priority", 5)
|
||||
metadata := req.GetString("metadata", "")
|
||||
|
||||
messages, err := ctr.channelService.BroadcastMessage(ctx, channelID, agentName, body, priority, metadata)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("send_channel_message failed: %s", err)), nil
|
||||
}
|
||||
|
||||
var messageID int64
|
||||
if len(messages) > 0 {
|
||||
messageID = messages[0].ID
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"message_id": messageID,
|
||||
"status": "sent",
|
||||
})
|
||||
}
|
||||
|
||||
func (ctr *ChannelToolRegistrar) handleUpdateChannel(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelID, err := ctr.resolveChannelID(ctx, req)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("update_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
updateReq := channels.UpdateChannelRequest{}
|
||||
args := req.GetArguments()
|
||||
if v, ok := args["topic"]; ok {
|
||||
if s, ok := v.(string); ok {
|
||||
updateReq.Topic = &s
|
||||
}
|
||||
}
|
||||
if v, ok := args["description"]; ok {
|
||||
if s, ok := v.(string); ok {
|
||||
updateReq.Description = &s
|
||||
}
|
||||
}
|
||||
|
||||
ch, err := ctr.channelService.UpdateChannel(ctx, channelID, updateReq, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("update_channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": ch.ID,
|
||||
"name": ch.Name,
|
||||
"description": ch.Description,
|
||||
"topic": ch.Topic,
|
||||
})
|
||||
}
|
||||
|
||||
// resolveChannelID resolves a channel ID from either channel_id or channel_name parameter.
|
||||
func (ctr *ChannelToolRegistrar) resolveChannelID(ctx context.Context, req mcp.CallToolRequest) (int64, error) {
|
||||
if cid := req.GetInt("channel_id", 0); cid > 0 {
|
||||
return int64(cid), nil
|
||||
}
|
||||
|
||||
name := req.GetString("channel_name", "")
|
||||
if name != "" {
|
||||
ch, err := ctr.channelService.GetChannelByName(ctx, name)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return ch.ID, nil
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("either 'channel_id' or 'channel_name' is required")
|
||||
}
|
||||
+119
-298
@@ -8,13 +8,16 @@ import (
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
func newTestChannelRegistrar(t *testing.T) (*ChannelToolRegistrar, *channels.Service) {
|
||||
func newTestHybridWithChannels(t *testing.T) (*HybridToolRegistrar, *channels.Service) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
@@ -26,12 +29,32 @@ func newTestChannelRegistrar(t *testing.T) (*ChannelToolRegistrar, *channels.Ser
|
||||
msgService := messaging.NewMessagingService(msgStore, tracer)
|
||||
channelService := channels.NewService(channelStore, msgService, tracer)
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
jsPool := jsruntime.NewPool(2)
|
||||
t.Cleanup(func() { jsPool.Close() })
|
||||
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
// Seed test agents
|
||||
db.Exec(`INSERT OR IGNORE INTO agents (name, display_name, type, capabilities, owner_id, api_key_hash, status) VALUES ('agent-a', 'Agent A', 'ai', '{}', 1, 'hash', 'active')`)
|
||||
db.Exec(`INSERT OR IGNORE INTO agents (name, display_name, type, capabilities, owner_id, api_key_hash, status) VALUES ('agent-b', 'Agent B', 'ai', '{}', 1, 'hash', 'active')`)
|
||||
db.Exec(`INSERT OR IGNORE INTO agents (name, display_name, type, capabilities, owner_id, api_key_hash, status) VALUES ('agent-c', 'Agent C', 'ai', '{}', 1, 'hash', 'active')`)
|
||||
|
||||
registrar := NewChannelToolRegistrar(channelService, msgService)
|
||||
registrar := NewHybridToolRegistrar(
|
||||
msgService,
|
||||
agentService,
|
||||
channelService,
|
||||
nil, // swarmService
|
||||
nil, // attachmentService
|
||||
nil, // searchService
|
||||
jsPool,
|
||||
actionRegistry,
|
||||
actionIndex,
|
||||
db,
|
||||
)
|
||||
return registrar, channelService
|
||||
}
|
||||
|
||||
@@ -45,274 +68,24 @@ func parseResponse(t *testing.T, result *mcplib.CallToolResult) map[string]any {
|
||||
return resp
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_CreateChannel(t *testing.T) {
|
||||
ctr, _ := newTestChannelRegistrar(t)
|
||||
authCtx := ContextWithAgentName(context.Background(), "agent-a")
|
||||
|
||||
t.Run("successful creation", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"name": "test-channel",
|
||||
"description": "A test channel",
|
||||
"type": "standard",
|
||||
})
|
||||
|
||||
result, err := ctr.handleCreateChannel(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleCreateChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resp := parseResponse(t, result)
|
||||
if resp["name"] != "test-channel" {
|
||||
t.Errorf("name = %v, want test-channel", resp["name"])
|
||||
}
|
||||
if resp["channel_id"] == nil || resp["channel_id"].(float64) == 0 {
|
||||
t.Error("expected non-zero channel_id")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("create private channel", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"name": "private-test",
|
||||
"is_private": true,
|
||||
})
|
||||
|
||||
result, err := ctr.handleCreateChannel(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleCreateChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resp := parseResponse(t, result)
|
||||
if resp["is_private"] != true {
|
||||
t.Errorf("is_private = %v, want true", resp["is_private"])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing name", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
result, _ := ctr.handleCreateChannel(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for missing name")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unauthenticated", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{"name": "fail"})
|
||||
result, _ := ctr.handleCreateChannel(context.Background(), req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for unauthenticated request")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("duplicate name", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{"name": "test-channel"})
|
||||
result, _ := ctr.handleCreateChannel(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for duplicate name")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_JoinChannel(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "join-test", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "agent-b")
|
||||
|
||||
t.Run("join by channel_id", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
})
|
||||
|
||||
result, err := ctr.handleJoinChannel(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleJoinChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resp := parseResponse(t, result)
|
||||
if resp["status"] != "joined" {
|
||||
t.Errorf("status = %v, want joined", resp["status"])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("join by channel_name", func(t *testing.T) {
|
||||
authCtxC := ContextWithAgentName(ctx, "agent-c")
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_name": "join-test",
|
||||
})
|
||||
|
||||
result, err := ctr.handleJoinChannel(authCtxC, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleJoinChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("no channel identifier", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
result, _ := ctr.handleJoinChannel(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error when no channel identifier provided")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_LeaveChannel(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "leave-test", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-b")
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "agent-b")
|
||||
|
||||
t.Run("successful leave", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
})
|
||||
|
||||
result, err := ctr.handleLeaveChannel(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleLeaveChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("owner cannot leave", func(t *testing.T) {
|
||||
ownerCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
})
|
||||
|
||||
result, _ := ctr.handleLeaveChannel(ownerCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for owner leaving")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_ListChannels(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
svc.CreateChannel(ctx, channels.CreateChannelRequest{Name: "pub-1", Type: "standard", CreatedBy: "agent-a"})
|
||||
svc.CreateChannel(ctx, channels.CreateChannelRequest{Name: "pub-2", Type: "standard", CreatedBy: "agent-a"})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "agent-b")
|
||||
|
||||
req := makeRequest(map[string]any{})
|
||||
result, err := ctr.handleListChannels(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleListChannels: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
// parseCallResult unwraps the execute response envelope and the call() wrapper
|
||||
// to return the inner bridge result: { result: { ok, result: <bridge_data> }, calls, duration } → <bridge_data>
|
||||
func parseCallResult(t *testing.T, result *mcplib.CallToolResult) map[string]any {
|
||||
t.Helper()
|
||||
resp := parseResponse(t, result)
|
||||
count := resp["count"].(float64)
|
||||
if count != 2 {
|
||||
t.Errorf("count = %v, want 2", count)
|
||||
callEnvelope, ok := resp["result"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected result to be map, got %T", resp["result"])
|
||||
}
|
||||
|
||||
chList := resp["channels"].([]any)
|
||||
ch0 := chList[0].(map[string]any)
|
||||
if ch0["name"] == nil {
|
||||
t.Error("expected name field in channel")
|
||||
}
|
||||
if ch0["member_count"] == nil {
|
||||
t.Error("expected member_count field in channel")
|
||||
inner, ok := callEnvelope["result"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected call result to be map, got %T (ok=%v)", callEnvelope["result"], callEnvelope["ok"])
|
||||
}
|
||||
return inner
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_InviteToChannel(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "invite-test", Type: "standard", IsPrivate: true, CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
ownerCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
|
||||
t.Run("owner can invite", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
"agent_name": "agent-b",
|
||||
})
|
||||
|
||||
result, err := ctr.handleInviteToChannel(ownerCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleInviteToChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing agent_name", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
})
|
||||
result, _ := ctr.handleInviteToChannel(ownerCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for missing agent_name")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_KickFromChannel(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "kick-test", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-b")
|
||||
|
||||
ownerCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
|
||||
t.Run("owner can kick", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
"agent_name": "agent-b",
|
||||
})
|
||||
|
||||
result, err := ctr.handleKickFromChannel(ownerCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleKickFromChannel: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resp := parseResponse(t, result)
|
||||
if resp["status"] != "kicked" {
|
||||
t.Errorf("status = %v, want kicked", resp["status"])
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_SendChannelMessage(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
func TestHybridTool_SendMessage_Channel(t *testing.T) {
|
||||
h, svc := newTestHybridWithChannels(t)
|
||||
ctx := context.Background()
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
@@ -322,15 +95,15 @@ func TestChannelToolHandler_SendChannelMessage(t *testing.T) {
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
|
||||
t.Run("send channel message", func(t *testing.T) {
|
||||
t.Run("send to channel by name", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_name": "msg-test",
|
||||
"body": "Hello channel!",
|
||||
"channel": "msg-test",
|
||||
"body": "Hello channel!",
|
||||
})
|
||||
|
||||
result, err := ctr.handleSendChannelMessage(authCtx, req)
|
||||
result, err := h.handleSendMessage(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSendChannelMessage: %v", err)
|
||||
t.Fatalf("handleSendMessage: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
@@ -345,57 +118,105 @@ func TestChannelToolHandler_SendChannelMessage(t *testing.T) {
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing body", func(t *testing.T) {
|
||||
t.Run("missing body for channel", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_name": "msg-test",
|
||||
"channel": "msg-test",
|
||||
})
|
||||
result, _ := ctr.handleSendChannelMessage(authCtx, req)
|
||||
result, _ := h.handleSendMessage(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for missing body")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestChannelToolHandler_UpdateChannel(t *testing.T) {
|
||||
ctr, svc := newTestChannelRegistrar(t)
|
||||
func TestBridge_ChannelOperations(t *testing.T) {
|
||||
h, svc := newTestHybridWithChannels(t)
|
||||
ctx := context.Background()
|
||||
authCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
|
||||
ch, _ := svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "update-test", Type: "standard", Topic: "Original", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
ownerCtx := ContextWithAgentName(ctx, "agent-a")
|
||||
|
||||
t.Run("update topic", func(t *testing.T) {
|
||||
t.Run("create_channel via execute", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
"topic": "Updated topic",
|
||||
"code": `call("create_channel", { name: "test-channel", description: "A test channel", type: "standard" })`,
|
||||
})
|
||||
|
||||
result, err := ctr.handleUpdateChannel(ownerCtx, req)
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleUpdateChannel: %v", err)
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resp := parseResponse(t, result)
|
||||
if resp["topic"] != "Updated topic" {
|
||||
t.Errorf("topic = %v, want 'Updated topic'", resp["topic"])
|
||||
resultData := parseCallResult(t, result)
|
||||
if resultData["name"] != "test-channel" {
|
||||
t.Errorf("name = %v, want test-channel", resultData["name"])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-owner cannot update", func(t *testing.T) {
|
||||
svc.JoinChannel(ctx, ch.ID, "agent-b")
|
||||
nonOwnerCtx := ContextWithAgentName(ctx, "agent-b")
|
||||
req := makeRequest(map[string]any{
|
||||
"channel_id": float64(ch.ID),
|
||||
"topic": "Unauthorized",
|
||||
t.Run("join_channel via execute", func(t *testing.T) {
|
||||
svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "join-test", Type: "standard", CreatedBy: "agent-a",
|
||||
})
|
||||
result, _ := ctr.handleUpdateChannel(nonOwnerCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for non-owner update")
|
||||
|
||||
bCtx := ContextWithAgentName(ctx, "agent-b")
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("join_channel", { channel_name: "join-test" })`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(bCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
if resultData["status"] != "joined" {
|
||||
t.Errorf("status = %v, want joined", resultData["status"])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("list_channels via execute", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("list_channels", {})`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
count := resultData["count"].(float64)
|
||||
if count < 1 {
|
||||
t.Errorf("expected at least 1 channel, got %v", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("update_channel via execute", func(t *testing.T) {
|
||||
svc.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "update-test", Type: "standard", Topic: "Original", CreatedBy: "agent-a",
|
||||
})
|
||||
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("update_channel", { channel_name: "update-test", topic: "Updated topic" })`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
if resultData["topic"] != "Updated topic" {
|
||||
t.Errorf("topic = %v, want 'Updated topic'", resultData["topic"])
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
@@ -0,0 +1,503 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
// PromptRegistrar registers MCP prompts on the server.
|
||||
type PromptRegistrar struct {
|
||||
db *sql.DB
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
traceStore trace.TraceStore
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewPromptRegistrar creates a new prompt registrar.
|
||||
func NewPromptRegistrar(
|
||||
db *sql.DB,
|
||||
agentService *agents.AgentService,
|
||||
channelService *channels.Service,
|
||||
traceStore trace.TraceStore,
|
||||
) *PromptRegistrar {
|
||||
return &PromptRegistrar{
|
||||
db: db,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
traceStore: traceStore,
|
||||
logger: slog.Default().With("component", "mcp-prompts"),
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAllOnServer registers all 4 MCP prompts on an mcp-go MCPServer.
|
||||
func (p *PromptRegistrar) RegisterAllOnServer(s *server.MCPServer) {
|
||||
s.AddPrompt(p.dailyDigestPrompt(), p.handleDailyDigest)
|
||||
s.AddPrompt(p.agentHealthCheckPrompt(), p.handleAgentHealthCheck)
|
||||
s.AddPrompt(p.channelOverviewPrompt(), p.handleChannelOverview)
|
||||
s.AddPrompt(p.debugAgentPrompt(), p.handleDebugAgent)
|
||||
|
||||
p.logger.Info("MCP prompts registered", "count", 4)
|
||||
}
|
||||
|
||||
// --- Prompt Definitions ---
|
||||
|
||||
func (p *PromptRegistrar) dailyDigestPrompt() mcplib.Prompt {
|
||||
return mcplib.NewPrompt("daily-digest",
|
||||
mcplib.WithPromptDescription("Summary of SynapBus activity in the last 24 hours: message counts, active agents, busiest channels, and high-priority messages."),
|
||||
)
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) agentHealthCheckPrompt() mcplib.Prompt {
|
||||
return mcplib.NewPrompt("agent-health-check",
|
||||
mcplib.WithPromptDescription("Status overview of all registered agents: name, type, status, last activity, and pending DM count. Flags agents needing attention."),
|
||||
)
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) channelOverviewPrompt() mcplib.Prompt {
|
||||
return mcplib.NewPrompt("channel-overview",
|
||||
mcplib.WithPromptDescription("Overview of all channels: name, type, member count, and recent message activity."),
|
||||
)
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) debugAgentPrompt() mcplib.Prompt {
|
||||
return mcplib.NewPrompt("debug-agent",
|
||||
mcplib.WithPromptDescription("Detailed debug information for a specific agent: identity, recent traces, pending messages, and errors."),
|
||||
mcplib.WithArgument("agent_name",
|
||||
mcplib.ArgumentDescription("Name of the agent to debug"),
|
||||
mcplib.RequiredArgument(),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Prompt Handlers ---
|
||||
|
||||
func (p *PromptRegistrar) handleDailyDigest(ctx context.Context, req mcplib.GetPromptRequest) (*mcplib.GetPromptResult, error) {
|
||||
since := time.Now().Add(-24 * time.Hour)
|
||||
|
||||
var md strings.Builder
|
||||
md.WriteString("# SynapBus Daily Digest\n\n")
|
||||
md.WriteString(fmt.Sprintf("*Period: %s to %s*\n\n", since.Format(time.RFC3339), time.Now().Format(time.RFC3339)))
|
||||
|
||||
// Total messages sent in last 24h
|
||||
var totalMessages int
|
||||
err := p.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE created_at >= ?`, since,
|
||||
).Scan(&totalMessages)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying messages: %s\n\n", err))
|
||||
} else {
|
||||
md.WriteString(fmt.Sprintf("## Messages\n\n**Total messages sent**: %d\n\n", totalMessages))
|
||||
}
|
||||
|
||||
// Active agents (those who sent messages in last 24h)
|
||||
rows, err := p.db.QueryContext(ctx,
|
||||
`SELECT DISTINCT from_agent FROM messages WHERE created_at >= ? AND from_agent != '' ORDER BY from_agent`,
|
||||
since,
|
||||
)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying active agents: %s\n\n", err))
|
||||
} else {
|
||||
var activeAgents []string
|
||||
for rows.Next() {
|
||||
var name string
|
||||
if err := rows.Scan(&name); err == nil {
|
||||
activeAgents = append(activeAgents, name)
|
||||
}
|
||||
}
|
||||
rows.Close()
|
||||
|
||||
md.WriteString("## Active Agents\n\n")
|
||||
if len(activeAgents) == 0 {
|
||||
md.WriteString("No agents were active in the last 24 hours.\n\n")
|
||||
} else {
|
||||
md.WriteString(fmt.Sprintf("**%d agents** sent messages: %s\n\n", len(activeAgents), strings.Join(activeAgents, ", ")))
|
||||
}
|
||||
}
|
||||
|
||||
// Top 3 busiest channels
|
||||
chanRows, err := p.db.QueryContext(ctx,
|
||||
`SELECT c.name, COUNT(m.id) as msg_count
|
||||
FROM messages m
|
||||
JOIN channels c ON m.channel_id = c.id
|
||||
WHERE m.created_at >= ? AND m.channel_id IS NOT NULL
|
||||
GROUP BY c.name
|
||||
ORDER BY msg_count DESC
|
||||
LIMIT 3`,
|
||||
since,
|
||||
)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying channels: %s\n\n", err))
|
||||
} else {
|
||||
md.WriteString("## Top Channels\n\n")
|
||||
md.WriteString("| Channel | Messages |\n")
|
||||
md.WriteString("|---------|----------|\n")
|
||||
found := false
|
||||
for chanRows.Next() {
|
||||
var chName string
|
||||
var msgCount int
|
||||
if err := chanRows.Scan(&chName, &msgCount); err == nil {
|
||||
md.WriteString(fmt.Sprintf("| #%s | %d |\n", chName, msgCount))
|
||||
found = true
|
||||
}
|
||||
}
|
||||
chanRows.Close()
|
||||
if !found {
|
||||
md.WriteString("| (no channel activity) | - |\n")
|
||||
}
|
||||
md.WriteString("\n")
|
||||
}
|
||||
|
||||
// High-priority messages (priority >= 7)
|
||||
highRows, err := p.db.QueryContext(ctx,
|
||||
`SELECT id, from_agent, COALESCE(to_agent, ''), body, priority, created_at
|
||||
FROM messages
|
||||
WHERE created_at >= ? AND priority >= 7
|
||||
ORDER BY priority DESC, created_at DESC
|
||||
LIMIT 20`,
|
||||
since,
|
||||
)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying high-priority messages: %s\n\n", err))
|
||||
} else {
|
||||
md.WriteString("## High-Priority Messages (>= 7)\n\n")
|
||||
var highPriorityFound bool
|
||||
for highRows.Next() {
|
||||
var id int64
|
||||
var from, to, body string
|
||||
var priority int
|
||||
var createdAt time.Time
|
||||
if err := highRows.Scan(&id, &from, &to, &body, &priority, &createdAt); err == nil {
|
||||
if !highPriorityFound {
|
||||
md.WriteString("| ID | From | To | Priority | Time | Body (truncated) |\n")
|
||||
md.WriteString("|----|------|----|----------|------|------------------|\n")
|
||||
highPriorityFound = true
|
||||
}
|
||||
if len(body) > 80 {
|
||||
body = body[:80] + "..."
|
||||
}
|
||||
// Escape pipe characters in body for markdown table
|
||||
body = strings.ReplaceAll(body, "|", "\\|")
|
||||
body = strings.ReplaceAll(body, "\n", " ")
|
||||
target := to
|
||||
if target == "" {
|
||||
target = "(channel)"
|
||||
}
|
||||
md.WriteString(fmt.Sprintf("| %d | %s | %s | %d | %s | %s |\n",
|
||||
id, from, target, priority, createdAt.Format("15:04"), body))
|
||||
}
|
||||
}
|
||||
highRows.Close()
|
||||
if !highPriorityFound {
|
||||
md.WriteString("No high-priority messages in the last 24 hours.\n")
|
||||
}
|
||||
md.WriteString("\n")
|
||||
}
|
||||
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "SynapBus activity summary for the last 24 hours",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(md.String()),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) handleAgentHealthCheck(ctx context.Context, req mcplib.GetPromptRequest) (*mcplib.GetPromptResult, error) {
|
||||
var md strings.Builder
|
||||
md.WriteString("# Agent Health Check\n\n")
|
||||
|
||||
// Get all active agents
|
||||
agentList, err := p.agentService.DiscoverAgents(ctx, "")
|
||||
if err != nil {
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "Agent health check",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(fmt.Sprintf("Error listing agents: %s", err)),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
md.WriteString("| Agent | Type | Status | Last Activity | Pending DMs | Notes |\n")
|
||||
md.WriteString("|-------|------|--------|---------------|-------------|-------|\n")
|
||||
|
||||
for _, agent := range agentList {
|
||||
if agent.Name == "system" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Get last activity from traces
|
||||
lastActivity := "unknown"
|
||||
if p.traceStore != nil {
|
||||
traces, err := p.traceStore.GetTraces(ctx, agent.Name, 1)
|
||||
if err == nil && len(traces) > 0 {
|
||||
lastActivity = traces[0].CreatedAt.Format("2006-01-02 15:04")
|
||||
}
|
||||
}
|
||||
|
||||
// Get pending DM count
|
||||
var pendingDMs int
|
||||
err := p.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE to_agent = ? AND status = 'pending'`,
|
||||
agent.Name,
|
||||
).Scan(&pendingDMs)
|
||||
if err != nil {
|
||||
pendingDMs = -1
|
||||
}
|
||||
|
||||
notes := ""
|
||||
if pendingDMs > 10 {
|
||||
notes = "**NEEDS ATTENTION**"
|
||||
}
|
||||
|
||||
pendingStr := fmt.Sprintf("%d", pendingDMs)
|
||||
if pendingDMs < 0 {
|
||||
pendingStr = "error"
|
||||
}
|
||||
|
||||
md.WriteString(fmt.Sprintf("| %s | %s | %s | %s | %s | %s |\n",
|
||||
agent.Name, agent.Type, agent.Status, lastActivity, pendingStr, notes))
|
||||
}
|
||||
|
||||
md.WriteString(fmt.Sprintf("\n*Total agents: %d*\n", len(agentList)-1)) // exclude system
|
||||
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "Status of all registered agents",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(md.String()),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) handleChannelOverview(ctx context.Context, req mcplib.GetPromptRequest) (*mcplib.GetPromptResult, error) {
|
||||
since := time.Now().Add(-24 * time.Hour)
|
||||
|
||||
var md strings.Builder
|
||||
md.WriteString("# Channel Overview\n\n")
|
||||
|
||||
// Query all channels with member counts and recent message counts
|
||||
rows, err := p.db.QueryContext(ctx,
|
||||
`SELECT c.id, c.name, c.type, c.is_private,
|
||||
(SELECT COUNT(*) FROM channel_members cm WHERE cm.channel_id = c.id) as member_count,
|
||||
(SELECT COUNT(*) FROM messages m WHERE m.channel_id = c.id AND m.created_at >= ?) as msg_count_24h
|
||||
FROM channels c
|
||||
ORDER BY c.name`,
|
||||
since,
|
||||
)
|
||||
if err != nil {
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "Channel overview",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(fmt.Sprintf("Error querying channels: %s", err)),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
md.WriteString("| Channel | Type | Private | Members | Messages (24h) |\n")
|
||||
md.WriteString("|---------|------|---------|---------|----------------|\n")
|
||||
|
||||
count := 0
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
var name, chType string
|
||||
var isPrivate int
|
||||
var memberCount, msgCount int
|
||||
|
||||
if err := rows.Scan(&id, &name, &chType, &isPrivate, &memberCount, &msgCount); err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
privateStr := "no"
|
||||
if isPrivate != 0 {
|
||||
privateStr = "yes"
|
||||
}
|
||||
|
||||
md.WriteString(fmt.Sprintf("| #%s | %s | %s | %d | %d |\n",
|
||||
name, chType, privateStr, memberCount, msgCount))
|
||||
count++
|
||||
}
|
||||
|
||||
if count == 0 {
|
||||
md.WriteString("| (no channels) | - | - | - | - |\n")
|
||||
}
|
||||
|
||||
md.WriteString(fmt.Sprintf("\n*Total channels: %d*\n", count))
|
||||
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "Overview of all channels",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(md.String()),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (p *PromptRegistrar) handleDebugAgent(ctx context.Context, req mcplib.GetPromptRequest) (*mcplib.GetPromptResult, error) {
|
||||
agentName := req.Params.Arguments["agent_name"]
|
||||
if agentName == "" {
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: "Debug agent",
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent("Error: agent_name argument is required"),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
var md strings.Builder
|
||||
md.WriteString(fmt.Sprintf("# Debug: Agent `%s`\n\n", agentName))
|
||||
|
||||
// Agent details
|
||||
agent, err := p.agentService.GetAgent(ctx, agentName)
|
||||
if err != nil {
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: fmt.Sprintf("Debug info for agent %s", agentName),
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(fmt.Sprintf("Error: agent not found: %s", err)),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Resolve owner name
|
||||
ownerName := "unknown"
|
||||
if p.db != nil {
|
||||
var username sql.NullString
|
||||
_ = p.db.QueryRowContext(ctx,
|
||||
`SELECT username FROM users WHERE id = ?`, agent.OwnerID,
|
||||
).Scan(&username)
|
||||
if username.Valid {
|
||||
ownerName = username.String
|
||||
}
|
||||
}
|
||||
|
||||
md.WriteString("## Identity\n\n")
|
||||
md.WriteString(fmt.Sprintf("| Field | Value |\n"))
|
||||
md.WriteString(fmt.Sprintf("|-------|-------|\n"))
|
||||
md.WriteString(fmt.Sprintf("| Name | %s |\n", agent.Name))
|
||||
md.WriteString(fmt.Sprintf("| Display Name | %s |\n", agent.DisplayName))
|
||||
md.WriteString(fmt.Sprintf("| Type | %s |\n", agent.Type))
|
||||
md.WriteString(fmt.Sprintf("| Status | %s |\n", agent.Status))
|
||||
md.WriteString(fmt.Sprintf("| Owner | %s (ID: %d) |\n", ownerName, agent.OwnerID))
|
||||
md.WriteString(fmt.Sprintf("| Capabilities | `%s` |\n", string(agent.Capabilities)))
|
||||
md.WriteString(fmt.Sprintf("| Created | %s |\n", agent.CreatedAt.Format(time.RFC3339)))
|
||||
md.WriteString("\n")
|
||||
|
||||
// Pending messages count
|
||||
var pendingCount int
|
||||
err = p.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE to_agent = ? AND status = 'pending'`,
|
||||
agentName,
|
||||
).Scan(&pendingCount)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying pending messages: %s\n\n", err))
|
||||
} else {
|
||||
md.WriteString(fmt.Sprintf("## Pending Messages\n\n**Count**: %d\n\n", pendingCount))
|
||||
}
|
||||
|
||||
// Recent traces (last 10)
|
||||
if p.traceStore != nil {
|
||||
traces, err := p.traceStore.GetTraces(ctx, agentName, 10)
|
||||
if err != nil {
|
||||
md.WriteString(fmt.Sprintf("Error querying traces: %s\n\n", err))
|
||||
} else {
|
||||
md.WriteString("## Recent Traces (last 10)\n\n")
|
||||
if len(traces) == 0 {
|
||||
md.WriteString("No traces found.\n\n")
|
||||
} else {
|
||||
md.WriteString("| Time | Action | Details | Error |\n")
|
||||
md.WriteString("|------|--------|---------|-------|\n")
|
||||
for _, t := range traces {
|
||||
details := t.Details
|
||||
if len(details) > 80 {
|
||||
details = details[:80] + "..."
|
||||
}
|
||||
details = strings.ReplaceAll(details, "|", "\\|")
|
||||
details = strings.ReplaceAll(details, "\n", " ")
|
||||
|
||||
errStr := ""
|
||||
if t.Error.Valid {
|
||||
errStr = t.Error.String
|
||||
if len(errStr) > 60 {
|
||||
errStr = errStr[:60] + "..."
|
||||
}
|
||||
errStr = strings.ReplaceAll(errStr, "|", "\\|")
|
||||
}
|
||||
|
||||
md.WriteString(fmt.Sprintf("| %s | %s | %s | %s |\n",
|
||||
t.CreatedAt.Format("15:04:05"), t.Action, details, errStr))
|
||||
}
|
||||
md.WriteString("\n")
|
||||
}
|
||||
}
|
||||
|
||||
// Recent errors from traces
|
||||
errorTraces, err := p.traceStore.GetTraces(ctx, agentName, 50)
|
||||
if err == nil {
|
||||
md.WriteString("## Recent Errors\n\n")
|
||||
errorFound := false
|
||||
for _, t := range errorTraces {
|
||||
if t.Error.Valid && t.Error.String != "" {
|
||||
if !errorFound {
|
||||
md.WriteString("| Time | Action | Error |\n")
|
||||
md.WriteString("|------|--------|-------|\n")
|
||||
errorFound = true
|
||||
}
|
||||
errStr := t.Error.String
|
||||
if len(errStr) > 100 {
|
||||
errStr = errStr[:100] + "..."
|
||||
}
|
||||
errStr = strings.ReplaceAll(errStr, "|", "\\|")
|
||||
errStr = strings.ReplaceAll(errStr, "\n", " ")
|
||||
md.WriteString(fmt.Sprintf("| %s | %s | %s |\n",
|
||||
t.CreatedAt.Format("2006-01-02 15:04:05"), t.Action, errStr))
|
||||
}
|
||||
}
|
||||
if !errorFound {
|
||||
md.WriteString("No recent errors found.\n")
|
||||
}
|
||||
md.WriteString("\n")
|
||||
}
|
||||
} else {
|
||||
md.WriteString("## Traces\n\n*Trace store not available*\n\n")
|
||||
}
|
||||
|
||||
return &mcplib.GetPromptResult{
|
||||
Description: fmt.Sprintf("Debug information for agent %s", agentName),
|
||||
Messages: []mcplib.PromptMessage{
|
||||
{
|
||||
Role: mcplib.RoleUser,
|
||||
Content: mcplib.NewTextContent(md.String()),
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
@@ -0,0 +1,339 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
func newTestPromptRegistrar(t *testing.T) (*PromptRegistrar, *messaging.MessagingService, *agents.AgentService, *channels.Service) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
tracer := trace.NewTracer(db)
|
||||
t.Cleanup(func() { tracer.Close() })
|
||||
|
||||
msgStore := messaging.NewSQLiteMessageStore(db)
|
||||
msgService := messaging.NewMessagingService(msgStore, tracer)
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
channelStore := channels.NewSQLiteChannelStore(db)
|
||||
channelService := channels.NewService(channelStore, msgService, tracer)
|
||||
|
||||
traceStore := trace.NewSQLiteTraceStore(db)
|
||||
|
||||
registrar := NewPromptRegistrar(db, agentService, channelService, traceStore)
|
||||
return registrar, msgService, agentService, channelService
|
||||
}
|
||||
|
||||
// extractPromptText extracts the text content from a GetPromptResult.
|
||||
func extractPromptText(t *testing.T, result *mcplib.GetPromptResult) string {
|
||||
t.Helper()
|
||||
if len(result.Messages) == 0 {
|
||||
t.Fatal("expected at least one prompt message")
|
||||
}
|
||||
tc, ok := result.Messages[0].Content.(mcplib.TextContent)
|
||||
if !ok {
|
||||
t.Fatalf("expected TextContent, got %T", result.Messages[0].Content)
|
||||
}
|
||||
return tc.Text
|
||||
}
|
||||
|
||||
func TestPrompt_DailyDigest(t *testing.T) {
|
||||
p, msgService, agentService, _ := newTestPromptRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Register agents
|
||||
agentService.Register(ctx, "agent-a", "Agent A", "ai", nil, 1)
|
||||
agentService.Register(ctx, "agent-b", "Agent B", "ai", nil, 1)
|
||||
|
||||
t.Run("empty system", func(t *testing.T) {
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleDailyDigest(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDailyDigest: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "Daily Digest") {
|
||||
t.Error("expected 'Daily Digest' in output")
|
||||
}
|
||||
if !strings.Contains(text, "Total messages sent") {
|
||||
t.Error("expected 'Total messages sent' in output")
|
||||
}
|
||||
if result.Messages[0].Role != mcplib.RoleUser {
|
||||
t.Errorf("expected role=user, got %s", result.Messages[0].Role)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("with messages", func(t *testing.T) {
|
||||
// Send some messages
|
||||
msgService.SendMessage(ctx, "agent-a", "agent-b", "hello", messaging.SendOptions{})
|
||||
msgService.SendMessage(ctx, "agent-b", "agent-a", "hi back", messaging.SendOptions{})
|
||||
msgService.SendMessage(ctx, "agent-a", "agent-b", "urgent!", messaging.SendOptions{Priority: 8})
|
||||
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleDailyDigest(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDailyDigest: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "agent-a") {
|
||||
t.Error("expected 'agent-a' in active agents")
|
||||
}
|
||||
if !strings.Contains(text, "agent-b") {
|
||||
t.Error("expected 'agent-b' in active agents")
|
||||
}
|
||||
// Should have the high priority message
|
||||
if !strings.Contains(text, "High-Priority") {
|
||||
t.Error("expected 'High-Priority' section in output")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPrompt_AgentHealthCheck(t *testing.T) {
|
||||
p, msgService, agentService, _ := newTestPromptRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("no agents", func(t *testing.T) {
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleAgentHealthCheck(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleAgentHealthCheck: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "Agent Health Check") {
|
||||
t.Error("expected 'Agent Health Check' header")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("with agents and pending DMs", func(t *testing.T) {
|
||||
agentService.Register(ctx, "healthy-agent", "Healthy", "ai", nil, 1)
|
||||
agentService.Register(ctx, "overloaded-agent", "Overloaded", "ai", nil, 1)
|
||||
|
||||
// Send 12 messages to overloaded-agent to trigger "NEEDS ATTENTION"
|
||||
for i := 0; i < 12; i++ {
|
||||
msgService.SendMessage(ctx, "healthy-agent", "overloaded-agent", "msg", messaging.SendOptions{})
|
||||
}
|
||||
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleAgentHealthCheck(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleAgentHealthCheck: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "healthy-agent") {
|
||||
t.Error("expected 'healthy-agent' in output")
|
||||
}
|
||||
if !strings.Contains(text, "overloaded-agent") {
|
||||
t.Error("expected 'overloaded-agent' in output")
|
||||
}
|
||||
if !strings.Contains(text, "NEEDS ATTENTION") {
|
||||
t.Error("expected 'NEEDS ATTENTION' flag for overloaded agent")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPrompt_ChannelOverview(t *testing.T) {
|
||||
p, _, agentService, channelService := newTestPromptRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("no channels", func(t *testing.T) {
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleChannelOverview(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleChannelOverview: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "Channel Overview") {
|
||||
t.Error("expected 'Channel Overview' header")
|
||||
}
|
||||
if !strings.Contains(text, "Total channels: 0") {
|
||||
t.Error("expected 'Total channels: 0' with no channels")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("with channels", func(t *testing.T) {
|
||||
agentService.Register(ctx, "chan-creator", "Chan Creator", "ai", nil, 1)
|
||||
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "general",
|
||||
Type: "standard",
|
||||
CreatedBy: "chan-creator",
|
||||
})
|
||||
channelService.CreateChannel(ctx, channels.CreateChannelRequest{
|
||||
Name: "private-ops",
|
||||
Type: "standard",
|
||||
IsPrivate: true,
|
||||
CreatedBy: "chan-creator",
|
||||
})
|
||||
|
||||
req := mcplib.GetPromptRequest{}
|
||||
result, err := p.handleChannelOverview(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleChannelOverview: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "general") {
|
||||
t.Error("expected 'general' channel in output")
|
||||
}
|
||||
if !strings.Contains(text, "private-ops") {
|
||||
t.Error("expected 'private-ops' channel in output")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPrompt_DebugAgent(t *testing.T) {
|
||||
p, msgService, agentService, _ := newTestPromptRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("missing agent_name", func(t *testing.T) {
|
||||
req := mcplib.GetPromptRequest{
|
||||
Params: mcplib.GetPromptParams{
|
||||
Name: "debug-agent",
|
||||
Arguments: map[string]string{},
|
||||
},
|
||||
}
|
||||
result, err := p.handleDebugAgent(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDebugAgent: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "agent_name argument is required") {
|
||||
t.Error("expected error message about missing agent_name")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("agent not found", func(t *testing.T) {
|
||||
req := mcplib.GetPromptRequest{
|
||||
Params: mcplib.GetPromptParams{
|
||||
Name: "debug-agent",
|
||||
Arguments: map[string]string{
|
||||
"agent_name": "nonexistent",
|
||||
},
|
||||
},
|
||||
}
|
||||
result, err := p.handleDebugAgent(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDebugAgent: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "agent not found") {
|
||||
t.Error("expected 'agent not found' error message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("agent exists", func(t *testing.T) {
|
||||
agentService.Register(ctx, "debug-target", "Debug Target", "ai", nil, 1)
|
||||
|
||||
// Send some messages to create pending DMs
|
||||
agentService.Register(ctx, "sender-for-debug", "Sender", "ai", nil, 1)
|
||||
msgService.SendMessage(ctx, "sender-for-debug", "debug-target", "test message", messaging.SendOptions{})
|
||||
|
||||
// Wait briefly for traces to flush
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
req := mcplib.GetPromptRequest{
|
||||
Params: mcplib.GetPromptParams{
|
||||
Name: "debug-agent",
|
||||
Arguments: map[string]string{
|
||||
"agent_name": "debug-target",
|
||||
},
|
||||
},
|
||||
}
|
||||
result, err := p.handleDebugAgent(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDebugAgent: %v", err)
|
||||
}
|
||||
|
||||
text := extractPromptText(t, result)
|
||||
if !strings.Contains(text, "debug-target") {
|
||||
t.Error("expected 'debug-target' in output")
|
||||
}
|
||||
if !strings.Contains(text, "Identity") {
|
||||
t.Error("expected 'Identity' section in output")
|
||||
}
|
||||
if !strings.Contains(text, "Pending Messages") {
|
||||
t.Error("expected 'Pending Messages' section in output")
|
||||
}
|
||||
if !strings.Contains(text, "Recent Traces") {
|
||||
t.Error("expected 'Recent Traces' section in output")
|
||||
}
|
||||
if !strings.Contains(text, "Recent Errors") {
|
||||
t.Error("expected 'Recent Errors' section in output")
|
||||
}
|
||||
if !strings.Contains(text, "testowner") {
|
||||
t.Error("expected owner name 'testowner' in output")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPrompt_Registration(t *testing.T) {
|
||||
p, _, _, _ := newTestPromptRegistrar(t)
|
||||
|
||||
// Verify prompt definitions
|
||||
t.Run("daily-digest prompt definition", func(t *testing.T) {
|
||||
prompt := p.dailyDigestPrompt()
|
||||
if prompt.Name != "daily-digest" {
|
||||
t.Errorf("name = %q, want daily-digest", prompt.Name)
|
||||
}
|
||||
if prompt.Description == "" {
|
||||
t.Error("expected non-empty description")
|
||||
}
|
||||
if len(prompt.Arguments) != 0 {
|
||||
t.Errorf("expected 0 arguments, got %d", len(prompt.Arguments))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("agent-health-check prompt definition", func(t *testing.T) {
|
||||
prompt := p.agentHealthCheckPrompt()
|
||||
if prompt.Name != "agent-health-check" {
|
||||
t.Errorf("name = %q, want agent-health-check", prompt.Name)
|
||||
}
|
||||
if len(prompt.Arguments) != 0 {
|
||||
t.Errorf("expected 0 arguments, got %d", len(prompt.Arguments))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("channel-overview prompt definition", func(t *testing.T) {
|
||||
prompt := p.channelOverviewPrompt()
|
||||
if prompt.Name != "channel-overview" {
|
||||
t.Errorf("name = %q, want channel-overview", prompt.Name)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("debug-agent prompt definition", func(t *testing.T) {
|
||||
prompt := p.debugAgentPrompt()
|
||||
if prompt.Name != "debug-agent" {
|
||||
t.Errorf("name = %q, want debug-agent", prompt.Name)
|
||||
}
|
||||
if len(prompt.Arguments) != 1 {
|
||||
t.Fatalf("expected 1 argument, got %d", len(prompt.Arguments))
|
||||
}
|
||||
arg := prompt.Arguments[0]
|
||||
if arg.Name != "agent_name" {
|
||||
t.Errorf("arg name = %q, want agent_name", arg.Name)
|
||||
}
|
||||
if !arg.Required {
|
||||
t.Error("expected agent_name to be required")
|
||||
}
|
||||
})
|
||||
}
|
||||
+26
-41
@@ -11,15 +11,15 @@ import (
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/console"
|
||||
"github.com/synapbus/synapbus/internal/k8s"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
"github.com/synapbus/synapbus/internal/webhooks"
|
||||
)
|
||||
|
||||
// MCPServer wraps the mcp-go server with SynapBus services.
|
||||
@@ -32,7 +32,7 @@ type MCPServer struct {
|
||||
console *console.Printer
|
||||
}
|
||||
|
||||
// NewMCPServer creates and configures a new MCP server with all tools registered.
|
||||
// NewMCPServer creates and configures a new MCP server with 4 hybrid tools registered.
|
||||
func NewMCPServer(
|
||||
msgService *messaging.MessagingService,
|
||||
agentService *agents.AgentService,
|
||||
@@ -41,8 +41,9 @@ func NewMCPServer(
|
||||
attachmentService *attachments.Service,
|
||||
searchService *search.Service,
|
||||
consolePrinter *console.Printer,
|
||||
webhookService *webhooks.WebhookService,
|
||||
k8sService *k8s.K8sService,
|
||||
jsPool *jsruntime.Pool,
|
||||
actionRegistry *actions.Registry,
|
||||
actionIndex *actions.Index,
|
||||
db *sql.DB,
|
||||
) *MCPServer {
|
||||
logger := slog.Default().With("component", "mcp-server")
|
||||
@@ -140,45 +141,29 @@ func NewMCPServer(
|
||||
"SynapBus",
|
||||
"0.1.0",
|
||||
server.WithToolCapabilities(true),
|
||||
server.WithPromptCapabilities(true),
|
||||
server.WithHooks(hooks),
|
||||
)
|
||||
|
||||
// Register all tools
|
||||
registrar := NewToolRegistrar(msgService, agentService)
|
||||
if searchService != nil {
|
||||
registrar.SetSearchService(searchService)
|
||||
}
|
||||
if channelService != nil {
|
||||
registrar.SetChannelService(channelService)
|
||||
}
|
||||
if db != nil {
|
||||
registrar.SetDB(db)
|
||||
}
|
||||
registrar.RegisterAll(mcpSrv)
|
||||
// Register the 4 hybrid tools
|
||||
hybridRegistrar := NewHybridToolRegistrar(
|
||||
msgService,
|
||||
agentService,
|
||||
channelService,
|
||||
swarmService,
|
||||
attachmentService,
|
||||
searchService,
|
||||
jsPool,
|
||||
actionRegistry,
|
||||
actionIndex,
|
||||
db,
|
||||
)
|
||||
hybridRegistrar.RegisterAllOnServer(mcpSrv)
|
||||
|
||||
// Register channel tools
|
||||
if channelService != nil {
|
||||
channelRegistrar := NewChannelToolRegistrar(channelService, msgService)
|
||||
channelRegistrar.RegisterAll(mcpSrv)
|
||||
}
|
||||
|
||||
// Register swarm tools
|
||||
if swarmService != nil && channelService != nil {
|
||||
swarmRegistrar := NewSwarmToolRegistrar(swarmService, channelService)
|
||||
swarmRegistrar.RegisterAll(mcpSrv)
|
||||
}
|
||||
|
||||
// Register attachment tools
|
||||
if attachmentService != nil {
|
||||
attachmentRegistrar := NewAttachmentToolRegistrar(attachmentService)
|
||||
attachmentRegistrar.RegisterAll(mcpSrv)
|
||||
}
|
||||
|
||||
// Register webhook and K8s handler tools
|
||||
if webhookService != nil || k8sService != nil {
|
||||
webhookRegistrar := NewWebhookToolRegistrar(webhookService, k8sService)
|
||||
webhookRegistrar.RegisterAll(mcpSrv)
|
||||
}
|
||||
// Register the 4 MCP prompts
|
||||
traceStore := trace.NewSQLiteTraceStore(db)
|
||||
promptRegistrar := NewPromptRegistrar(db, agentService, channelService, traceStore)
|
||||
promptRegistrar.RegisterAllOnServer(mcpSrv)
|
||||
|
||||
// Create Streamable HTTP transport with context func for auth propagation
|
||||
httpServer := server.NewStreamableHTTPServer(mcpSrv,
|
||||
@@ -204,7 +189,7 @@ func NewMCPServer(
|
||||
console: consolePrinter,
|
||||
}
|
||||
|
||||
logger.Info("MCP server initialized (streamable HTTP transport)")
|
||||
logger.Info("MCP server initialized (4 hybrid tools, 4 prompts, streamable HTTP transport)")
|
||||
return s
|
||||
}
|
||||
|
||||
|
||||
+46
-44
@@ -2,7 +2,6 @@ package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
@@ -10,14 +9,18 @@ import (
|
||||
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/apikeys"
|
||||
"github.com/synapbus/synapbus/internal/console"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
func TestNewMCPServerWithConsole(t *testing.T) {
|
||||
// newTestMCPServer creates a full MCPServer for testing.
|
||||
func newTestMCPServer(t *testing.T, con *console.Printer) (*MCPServer, *messaging.MessagingService, *agents.AgentService) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
tracer := trace.NewTracer(db)
|
||||
@@ -29,9 +32,19 @@ func TestNewMCPServerWithConsole(t *testing.T) {
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
con := console.New()
|
||||
jsPool := jsruntime.NewPool(2)
|
||||
t.Cleanup(func() { jsPool.Close() })
|
||||
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, con, nil, nil, nil)
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, con, jsPool, actionRegistry, actionIndex, db)
|
||||
return srv, msgService, agentService
|
||||
}
|
||||
|
||||
func TestNewMCPServerWithConsole(t *testing.T) {
|
||||
con := console.New()
|
||||
srv, _, _ := newTestMCPServer(t, con)
|
||||
if srv == nil {
|
||||
t.Fatal("expected non-nil MCPServer")
|
||||
}
|
||||
@@ -44,19 +57,7 @@ func TestNewMCPServerWithConsole(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestNewMCPServerNilConsole(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
|
||||
tracer := trace.NewTracer(db)
|
||||
t.Cleanup(func() { tracer.Close() })
|
||||
|
||||
msgStore := messaging.NewSQLiteMessageStore(db)
|
||||
msgService := messaging.NewMessagingService(msgStore, tracer)
|
||||
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
// nil console should not panic
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, nil, nil, nil, nil)
|
||||
srv, _, _ := newTestMCPServer(t, nil)
|
||||
if srv == nil {
|
||||
t.Fatal("expected non-nil MCPServer")
|
||||
}
|
||||
@@ -99,7 +100,7 @@ func TestConnectionManagerClientInfo(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// T007: Test MCP tool calls with valid API key — agent identity is correctly resolved.
|
||||
// T007: Test MCP tool calls with valid API key -- agent identity is correctly resolved.
|
||||
func TestMCPToolCall_WithValidAPIKey(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
ctx := context.Background()
|
||||
@@ -125,8 +126,14 @@ func TestMCPToolCall_WithValidAPIKey(t *testing.T) {
|
||||
// Also register a receiver
|
||||
agentService.Register(ctx, "receiver", "Receiver", "ai", nil, 1)
|
||||
|
||||
jsPool := jsruntime.NewPool(2)
|
||||
defer jsPool.Close()
|
||||
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
// Create MCP server
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, nil, nil, nil, nil)
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, nil, jsPool, actionRegistry, actionIndex, db)
|
||||
|
||||
// Mount with auth middleware, just like main.go does
|
||||
mux := http.NewServeMux()
|
||||
@@ -156,15 +163,10 @@ func TestMCPToolCall_WithValidAPIKey(t *testing.T) {
|
||||
t.Errorf("expected 200, got %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
// Verify the agent was authenticated by checking the connection manager
|
||||
// (the AfterInitialize hook would have captured the agent name)
|
||||
// The init should have succeeded — verify by checking no 401 was returned
|
||||
t.Log("MCP connection with valid API key succeeded")
|
||||
}
|
||||
|
||||
// T008: Test MCP tool calls without auth return 401 when auth is required.
|
||||
// Note: With the current OptionalAuthMiddleware, unauthenticated requests pass through
|
||||
// (returning tool-level errors). This test verifies that an invalid API key is rejected.
|
||||
func TestMCPToolCall_InvalidAPIKeyReturns401(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
|
||||
@@ -180,7 +182,13 @@ func TestMCPToolCall_InvalidAPIKeyReturns401(t *testing.T) {
|
||||
apiKeyStore := apikeys.NewSQLiteStore(db)
|
||||
apiKeyService := apikeys.NewService(apiKeyStore)
|
||||
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, nil, nil, nil, nil)
|
||||
jsPool := jsruntime.NewPool(2)
|
||||
defer jsPool.Close()
|
||||
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
srv := NewMCPServer(msgService, agentService, nil, nil, nil, nil, nil, jsPool, actionRegistry, actionIndex, db)
|
||||
|
||||
mux := http.NewServeMux()
|
||||
handler := agents.OptionalAuthMiddlewareWithAPIKeys(agentService, apiKeyService)(srv.Handler())
|
||||
@@ -212,7 +220,7 @@ func TestMCPToolCall_InvalidAPIKeyReturns401(t *testing.T) {
|
||||
// T008 (continued): Test that unauthenticated MCP tool calls (no auth header at all)
|
||||
// are rejected at the tool handler level.
|
||||
func TestMCPToolCall_NoAuthReturnsToolError(t *testing.T) {
|
||||
tr, _, agentSvc, _ := newTestRegistrar(t)
|
||||
h, _, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Register a receiver so the send would work if auth was present
|
||||
@@ -224,7 +232,7 @@ func TestMCPToolCall_NoAuthReturnsToolError(t *testing.T) {
|
||||
"body": "should fail",
|
||||
})
|
||||
|
||||
result, err := tr.handleSendMessage(ctx, req)
|
||||
result, err := h.handleSendMessage(ctx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSendMessage returned error: %v", err)
|
||||
}
|
||||
@@ -239,10 +247,8 @@ func TestMCPToolCall_NoAuthReturnsToolError(t *testing.T) {
|
||||
}
|
||||
|
||||
// T009: Verify send_message enforces from_agent from the authenticated context.
|
||||
// The send_message tool does NOT expose a "from" parameter — the sender is always
|
||||
// derived from the authenticated agent identity in the context.
|
||||
func TestSendMessage_EnforcesAuthenticatedAgent(t *testing.T) {
|
||||
tr, _, agentSvc, _ := newTestRegistrar(t)
|
||||
h, _, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "real-sender", "Real Sender", "ai", nil, 1)
|
||||
@@ -252,16 +258,13 @@ func TestSendMessage_EnforcesAuthenticatedAgent(t *testing.T) {
|
||||
// Authenticate as "real-sender"
|
||||
authCtx := ContextWithAgentName(ctx, "real-sender")
|
||||
|
||||
// Try to send a message — even if someone could supply a "from" field,
|
||||
// the handler should use the authenticated agent name, not a user-supplied value.
|
||||
// Send a message
|
||||
req := makeRequest(map[string]any{
|
||||
"to": "receiver",
|
||||
"body": "message from real sender",
|
||||
// Note: there is no "from" parameter in the send_message tool definition,
|
||||
// but even if extra args are passed, the handler ignores them.
|
||||
})
|
||||
|
||||
result, err := tr.handleSendMessage(authCtx, req)
|
||||
result, err := h.handleSendMessage(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSendMessage: %v", err)
|
||||
}
|
||||
@@ -269,16 +272,15 @@ func TestSendMessage_EnforcesAuthenticatedAgent(t *testing.T) {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
// Verify the message was sent from "real-sender" by reading receiver's inbox
|
||||
// Verify the message was sent from "real-sender" by reading receiver's inbox via execute
|
||||
inboxCtx := ContextWithAgentName(ctx, "receiver")
|
||||
inboxReq := makeRequest(map[string]any{})
|
||||
inboxResult, _ := tr.handleReadInbox(inboxCtx, inboxReq)
|
||||
inboxReq := makeRequest(map[string]any{
|
||||
"code": `call("read_inbox", {})`,
|
||||
})
|
||||
inboxResult, _ := h.handleExecute(inboxCtx, inboxReq)
|
||||
|
||||
text := inboxResult.Content[0].(mcplib.TextContent).Text
|
||||
var resp map[string]any
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
|
||||
messages := resp["messages"].([]any)
|
||||
resultData := parseCallResult(t, inboxResult)
|
||||
messages := resultData["messages"].([]any)
|
||||
if len(messages) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d", len(messages))
|
||||
}
|
||||
@@ -286,6 +288,6 @@ func TestSendMessage_EnforcesAuthenticatedAgent(t *testing.T) {
|
||||
msg := messages[0].(map[string]any)
|
||||
fromAgent := msg["from_agent"].(string)
|
||||
if fromAgent != "real-sender" {
|
||||
t.Errorf("message from_agent = %q, want %q — send_message must enforce authenticated agent", fromAgent, "real-sender")
|
||||
t.Errorf("message from_agent = %q, want %q -- send_message must enforce authenticated agent", fromAgent, "real-sender")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,285 +0,0 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
)
|
||||
|
||||
// SwarmToolRegistrar registers swarm-pattern MCP tools on the server.
|
||||
type SwarmToolRegistrar struct {
|
||||
swarmService *channels.SwarmService
|
||||
channelService *channels.Service
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewSwarmToolRegistrar creates a new swarm tool registrar.
|
||||
func NewSwarmToolRegistrar(swarmService *channels.SwarmService, channelService *channels.Service) *SwarmToolRegistrar {
|
||||
return &SwarmToolRegistrar{
|
||||
swarmService: swarmService,
|
||||
channelService: channelService,
|
||||
logger: slog.Default().With("component", "mcp-swarm-tools"),
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAll registers all swarm tools on the MCP server.
|
||||
func (str *SwarmToolRegistrar) RegisterAll(s *server.MCPServer) {
|
||||
s.AddTool(str.postTaskTool(), str.handlePostTask)
|
||||
s.AddTool(str.bidTaskTool(), str.handleBidTask)
|
||||
s.AddTool(str.acceptBidTool(), str.handleAcceptBid)
|
||||
s.AddTool(str.completeTaskTool(), str.handleCompleteTask)
|
||||
s.AddTool(str.listTasksTool(), str.handleListTasks)
|
||||
|
||||
str.logger.Info("swarm MCP tools registered", "count", 5)
|
||||
}
|
||||
|
||||
// --- Tool Definitions ---
|
||||
|
||||
func (str *SwarmToolRegistrar) postTaskTool() mcp.Tool {
|
||||
return mcp.NewTool("post_task",
|
||||
mcp.WithDescription("Post a task to an auction channel for agents to bid on"),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the auction channel"), mcp.Required()),
|
||||
mcp.WithString("title", mcp.Description("Task title"), mcp.Required()),
|
||||
mcp.WithString("description", mcp.Description("Task description")),
|
||||
mcp.WithString("requirements", mcp.Description("JSON object of task requirements")),
|
||||
mcp.WithString("deadline", mcp.Description("Task deadline in ISO 8601 format (e.g. 2026-03-13T15:00:00Z)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) bidTaskTool() mcp.Tool {
|
||||
return mcp.NewTool("bid_task",
|
||||
mcp.WithDescription("Submit a bid on an open task in an auction channel"),
|
||||
mcp.WithNumber("task_id", mcp.Description("ID of the task to bid on"), mcp.Required()),
|
||||
mcp.WithString("capabilities", mcp.Description("JSON object describing your relevant capabilities")),
|
||||
mcp.WithString("time_estimate", mcp.Description("Estimated time to complete the task")),
|
||||
mcp.WithString("message", mcp.Description("Message to the task poster explaining your bid")),
|
||||
)
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) acceptBidTool() mcp.Tool {
|
||||
return mcp.NewTool("accept_bid",
|
||||
mcp.WithDescription("Accept a bid on a task you posted, assigning the task to the bidding agent"),
|
||||
mcp.WithNumber("task_id", mcp.Description("ID of the task"), mcp.Required()),
|
||||
mcp.WithNumber("bid_id", mcp.Description("ID of the bid to accept"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) completeTaskTool() mcp.Tool {
|
||||
return mcp.NewTool("complete_task",
|
||||
mcp.WithDescription("Mark a task as completed (only the assigned agent can do this)"),
|
||||
mcp.WithNumber("task_id", mcp.Description("ID of the task to complete"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) listTasksTool() mcp.Tool {
|
||||
return mcp.NewTool("list_tasks",
|
||||
mcp.WithDescription("List tasks in an auction channel, optionally filtered by status"),
|
||||
mcp.WithString("channel_name", mcp.Description("Name of the auction channel"), mcp.Required()),
|
||||
mcp.WithString("status", mcp.Description("Filter by task status: open, assigned, completed, cancelled")),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Tool Handlers ---
|
||||
|
||||
func (str *SwarmToolRegistrar) handlePostTask(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
channelName := req.GetString("channel_name", "")
|
||||
if channelName == "" {
|
||||
return mcp.NewToolResultError("'channel_name' parameter is required"), nil
|
||||
}
|
||||
|
||||
title := req.GetString("title", "")
|
||||
if title == "" {
|
||||
return mcp.NewToolResultError("'title' parameter is required"), nil
|
||||
}
|
||||
|
||||
description := req.GetString("description", "")
|
||||
requirementsStr := req.GetString("requirements", "{}")
|
||||
deadlineStr := req.GetString("deadline", "")
|
||||
|
||||
// Parse requirements JSON
|
||||
var requirements json.RawMessage
|
||||
if requirementsStr != "" {
|
||||
if !json.Valid([]byte(requirementsStr)) {
|
||||
return mcp.NewToolResultError("requirements must be valid JSON"), nil
|
||||
}
|
||||
requirements = json.RawMessage(requirementsStr)
|
||||
}
|
||||
|
||||
// Parse deadline
|
||||
var deadline *time.Time
|
||||
if deadlineStr != "" {
|
||||
t, err := time.Parse(time.RFC3339, deadlineStr)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("deadline must be ISO 8601 format: %s", err)), nil
|
||||
}
|
||||
deadline = &t
|
||||
}
|
||||
|
||||
// Resolve channel
|
||||
ch, err := str.channelService.GetChannelByName(ctx, channelName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("post_task failed: %s", err)), nil
|
||||
}
|
||||
|
||||
task, err := str.swarmService.PostTask(ctx, ch.ID, agentName, title, description, requirements, deadline)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("post_task failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"task_id": task.ID,
|
||||
"channel_id": task.ChannelID,
|
||||
"title": task.Title,
|
||||
"status": task.Status,
|
||||
"posted_by": task.PostedBy,
|
||||
"deadline": task.Deadline,
|
||||
"created_at": task.CreatedAt,
|
||||
})
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) handleBidTask(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
taskID, err := req.RequireInt("task_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'task_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
capabilitiesStr := req.GetString("capabilities", "{}")
|
||||
timeEstimate := req.GetString("time_estimate", "")
|
||||
message := req.GetString("message", "")
|
||||
|
||||
var capabilities json.RawMessage
|
||||
if capabilitiesStr != "" {
|
||||
if !json.Valid([]byte(capabilitiesStr)) {
|
||||
return mcp.NewToolResultError("capabilities must be valid JSON"), nil
|
||||
}
|
||||
capabilities = json.RawMessage(capabilitiesStr)
|
||||
}
|
||||
|
||||
bid, err := str.swarmService.BidOnTask(ctx, int64(taskID), agentName, capabilities, timeEstimate, message)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("bid_task failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"bid_id": bid.ID,
|
||||
"task_id": bid.TaskID,
|
||||
"agent_name": bid.AgentName,
|
||||
"time_estimate": bid.TimeEstimate,
|
||||
"status": bid.Status,
|
||||
})
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) handleAcceptBid(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
taskID, err := req.RequireInt("task_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'task_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
bidID, err := req.RequireInt("bid_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'bid_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := str.swarmService.AcceptBid(ctx, int64(taskID), int64(bidID), agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("accept_bid failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"task_id": taskID,
|
||||
"bid_id": bidID,
|
||||
"status": "accepted",
|
||||
})
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) handleCompleteTask(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
taskID, err := req.RequireInt("task_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'task_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := str.swarmService.CompleteTask(ctx, int64(taskID), agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("complete_task failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"task_id": taskID,
|
||||
"status": "completed",
|
||||
})
|
||||
}
|
||||
|
||||
func (str *SwarmToolRegistrar) handleListTasks(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
_ = agentName // just verifying auth
|
||||
|
||||
channelName := req.GetString("channel_name", "")
|
||||
if channelName == "" {
|
||||
return mcp.NewToolResultError("'channel_name' parameter is required"), nil
|
||||
}
|
||||
|
||||
statusFilter := req.GetString("status", "")
|
||||
|
||||
// Resolve channel
|
||||
ch, err := str.channelService.GetChannelByName(ctx, channelName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_tasks failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Verify channel is auction type
|
||||
if ch.Type != channels.TypeAuction {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_tasks requires a channel of type 'auction', got '%s'", ch.Type)), nil
|
||||
}
|
||||
|
||||
tasks, err := str.swarmService.ListTasks(ctx, ch.ID, statusFilter)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_tasks failed: %s", err)), nil
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(tasks))
|
||||
for i, task := range tasks {
|
||||
result[i] = map[string]any{
|
||||
"id": task.ID,
|
||||
"title": task.Title,
|
||||
"description": task.Description,
|
||||
"status": task.Status,
|
||||
"posted_by": task.PostedBy,
|
||||
"assigned_to": task.AssignedTo,
|
||||
"deadline": task.Deadline,
|
||||
"created_at": task.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"tasks": result,
|
||||
"count": len(result),
|
||||
})
|
||||
}
|
||||
@@ -1,564 +1,12 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
)
|
||||
|
||||
// ToolRegistrar registers all SynapBus MCP tools on the given server.
|
||||
type ToolRegistrar struct {
|
||||
msgService *messaging.MessagingService
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
searchService *search.Service
|
||||
db *sql.DB
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewToolRegistrar creates a new tool registrar.
|
||||
func NewToolRegistrar(msgService *messaging.MessagingService, agentService *agents.AgentService) *ToolRegistrar {
|
||||
return &ToolRegistrar{
|
||||
msgService: msgService,
|
||||
agentService: agentService,
|
||||
logger: slog.Default().With("component", "mcp-tools"),
|
||||
}
|
||||
}
|
||||
|
||||
// SetSearchService sets the search service for semantic search support.
|
||||
func (tr *ToolRegistrar) SetSearchService(svc *search.Service) {
|
||||
tr.searchService = svc
|
||||
}
|
||||
|
||||
// SetChannelService sets the channel service for my_status support.
|
||||
func (tr *ToolRegistrar) SetChannelService(svc *channels.Service) {
|
||||
tr.channelService = svc
|
||||
}
|
||||
|
||||
// SetDB sets the database handle for direct queries (e.g. owner name lookup).
|
||||
func (tr *ToolRegistrar) SetDB(db *sql.DB) {
|
||||
tr.db = db
|
||||
}
|
||||
|
||||
// RegisterAll registers all tools on the MCP server.
|
||||
// Note: Agent management tools (register, update, deregister) are NOT exposed via MCP.
|
||||
// Agents are managed exclusively through the Web UI. MCP is for messaging only.
|
||||
func (tr *ToolRegistrar) RegisterAll(s *server.MCPServer) {
|
||||
s.AddTool(tr.myStatusTool(), tr.handleMyStatus)
|
||||
s.AddTool(tr.sendMessageTool(), tr.handleSendMessage)
|
||||
s.AddTool(tr.readInboxTool(), tr.handleReadInbox)
|
||||
s.AddTool(tr.claimMessagesTool(), tr.handleClaimMessages)
|
||||
s.AddTool(tr.markDoneTool(), tr.handleMarkDone)
|
||||
s.AddTool(tr.searchMessagesTool(), tr.handleSearchMessages)
|
||||
s.AddTool(tr.discoverAgentsTool(), tr.handleDiscoverAgents)
|
||||
|
||||
tr.logger.Info("all MCP tools registered", "count", 7)
|
||||
}
|
||||
|
||||
// --- Tool Definitions ---
|
||||
|
||||
func (tr *ToolRegistrar) sendMessageTool() mcp.Tool {
|
||||
return mcp.NewTool("send_message",
|
||||
mcp.WithDescription("Send a direct message to another agent. Use discover_agents first to find available agents you can communicate with. For channel messages, use send_channel_message instead."),
|
||||
mcp.WithString("to", mcp.Description("Name of the recipient agent (required for DMs, omit for channel messages)")),
|
||||
mcp.WithString("body", mcp.Description("Message body text"), mcp.Required()),
|
||||
mcp.WithString("subject", mcp.Description("Conversation subject (optional)")),
|
||||
mcp.WithNumber("priority", mcp.Description("Message priority (1-10, default 5)"), mcp.Min(1), mcp.Max(10)),
|
||||
mcp.WithString("metadata", mcp.Description("JSON metadata object (optional)")),
|
||||
mcp.WithNumber("channel_id", mcp.Description("Channel ID for channel messages (optional)")),
|
||||
mcp.WithNumber("reply_to", mcp.Description("ID of the message to reply to (optional, for threading)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) readInboxTool() mcp.Tool {
|
||||
return mcp.NewTool("read_inbox",
|
||||
mcp.WithDescription("Check your message inbox for pending messages. Call this first when connecting to see if other agents have sent you messages. Returns unread/pending direct messages addressed to you."),
|
||||
mcp.WithNumber("limit", mcp.Description("Maximum number of messages to return (default 50)")),
|
||||
mcp.WithString("status_filter", mcp.Description("Filter by message status: pending, processing, done, failed")),
|
||||
mcp.WithBoolean("include_read", mcp.Description("Include previously read messages (default false)")),
|
||||
mcp.WithNumber("min_priority", mcp.Description("Minimum priority filter (1-10)")),
|
||||
mcp.WithString("from_agent", mcp.Description("Filter by sender agent name")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) claimMessagesTool() mcp.Tool {
|
||||
return mcp.NewTool("claim_messages",
|
||||
mcp.WithDescription("Atomically claim pending messages for processing"),
|
||||
mcp.WithNumber("limit", mcp.Description("Maximum number of messages to claim (default 10)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) markDoneTool() mcp.Tool {
|
||||
return mcp.NewTool("mark_done",
|
||||
mcp.WithDescription("Mark a claimed message as done or failed"),
|
||||
mcp.WithNumber("message_id", mcp.Description("ID of the message to mark"), mcp.Required()),
|
||||
mcp.WithString("status", mcp.Description("New status: 'done' or 'failed' (default 'done')")),
|
||||
mcp.WithString("reason", mcp.Description("Failure reason (only for status='failed')")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) searchMessagesTool() mcp.Tool {
|
||||
return mcp.NewTool("search_messages",
|
||||
mcp.WithDescription("Search for messages across your inbox and channels you are a member of. Supports full-text and semantic search (if configured). Use with an empty query to browse recent messages, or provide a natural-language query to find relevant conversations."),
|
||||
mcp.WithString("query", mcp.Description("Search query string — supports natural language for semantic search")),
|
||||
mcp.WithNumber("limit", mcp.Description("Maximum results to return (default 10, max 100)")),
|
||||
mcp.WithNumber("min_priority", mcp.Description("Minimum priority filter (1-10)")),
|
||||
mcp.WithString("from_agent", mcp.Description("Filter by sender agent name")),
|
||||
mcp.WithString("status", mcp.Description("Filter by message status")),
|
||||
mcp.WithString("search_mode", mcp.Description("Search mode: 'auto' (default), 'semantic', or 'fulltext'")),
|
||||
mcp.WithBoolean("semantic", mcp.Description("Force semantic search (shorthand for search_mode='semantic')")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) discoverAgentsTool() mcp.Tool {
|
||||
return mcp.NewTool("discover_agents",
|
||||
mcp.WithDescription("Discover other agents on the bus. Call this to find agents you can communicate with. Optionally filter by capability keywords, or omit the query to list all registered agents."),
|
||||
mcp.WithString("query", mcp.Description("Capability keyword to search for")),
|
||||
)
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) myStatusTool() mcp.Tool {
|
||||
return mcp.NewTool("my_status",
|
||||
mcp.WithDescription("Get your complete status overview — identity, pending messages, channel mentions, system notifications, and statistics. Call this first when connecting to SynapBus."),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Tool Handlers ---
|
||||
|
||||
func (tr *ToolRegistrar) handleSendMessage(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
to := req.GetString("to", "")
|
||||
body := req.GetString("body", "")
|
||||
subject := req.GetString("subject", "")
|
||||
priority := req.GetInt("priority", 5)
|
||||
metadataStr := req.GetString("metadata", "")
|
||||
|
||||
if body == "" {
|
||||
return mcp.NewToolResultError("'body' parameter is required"), nil
|
||||
}
|
||||
|
||||
var channelID *int64
|
||||
if cid := req.GetInt("channel_id", 0); cid > 0 {
|
||||
v := int64(cid)
|
||||
channelID = &v
|
||||
}
|
||||
|
||||
var replyTo *int64
|
||||
if rtID := req.GetInt("reply_to", 0); rtID > 0 {
|
||||
v := int64(rtID)
|
||||
replyTo = &v
|
||||
}
|
||||
|
||||
opts := messaging.SendOptions{
|
||||
Subject: subject,
|
||||
Priority: priority,
|
||||
Metadata: metadataStr,
|
||||
ChannelID: channelID,
|
||||
ReplyTo: replyTo,
|
||||
}
|
||||
|
||||
msg, err := tr.msgService.SendMessage(ctx, agentName, to, body, opts)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("send_message failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"message_id": msg.ID,
|
||||
"conversation_id": msg.ConversationID,
|
||||
"status": msg.Status,
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleReadInbox(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
opts := messaging.ReadOptions{
|
||||
Limit: req.GetInt("limit", 50),
|
||||
Status: req.GetString("status_filter", ""),
|
||||
MinPriority: req.GetInt("min_priority", 0),
|
||||
FromAgent: req.GetString("from_agent", ""),
|
||||
}
|
||||
|
||||
// Handle include_read boolean
|
||||
args := req.GetArguments()
|
||||
if v, ok := args["include_read"]; ok {
|
||||
if b, ok := v.(bool); ok {
|
||||
opts.IncludeRead = b
|
||||
}
|
||||
}
|
||||
|
||||
messages, err := tr.msgService.ReadInbox(ctx, agentName, opts)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("read_inbox failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"messages": messages,
|
||||
"count": len(messages),
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleClaimMessages(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
limit := req.GetInt("limit", 10)
|
||||
|
||||
messages, err := tr.msgService.ClaimMessages(ctx, agentName, limit)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("claim_messages failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"messages": messages,
|
||||
"count": len(messages),
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleMarkDone(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
messageID, err := req.RequireInt("message_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'message_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
status := req.GetString("status", "done")
|
||||
reason := req.GetString("reason", "")
|
||||
|
||||
switch status {
|
||||
case "done":
|
||||
if err := tr.msgService.MarkDone(ctx, int64(messageID), agentName); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("mark_done failed: %s", err)), nil
|
||||
}
|
||||
case "failed":
|
||||
if err := tr.msgService.MarkFailed(ctx, int64(messageID), agentName, reason); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("mark_failed failed: %s", err)), nil
|
||||
}
|
||||
default:
|
||||
return mcp.NewToolResultError("status must be 'done' or 'failed'"), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"message_id": messageID,
|
||||
"status": status,
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleSearchMessages(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
query := req.GetString("query", "")
|
||||
|
||||
// If search service is available, use it for unified search
|
||||
if tr.searchService != nil {
|
||||
searchMode := req.GetString("search_mode", "auto")
|
||||
|
||||
// Handle boolean "semantic" shorthand
|
||||
args := req.GetArguments()
|
||||
if v, ok := args["semantic"]; ok {
|
||||
if b, ok := v.(bool); ok && b {
|
||||
searchMode = "semantic"
|
||||
}
|
||||
}
|
||||
|
||||
opts := search.SearchOptions{
|
||||
Query: query,
|
||||
Mode: searchMode,
|
||||
Limit: req.GetInt("limit", 10),
|
||||
FromAgent: req.GetString("from_agent", ""),
|
||||
MinPriority: req.GetInt("min_priority", 0),
|
||||
}
|
||||
|
||||
resp, err := tr.searchService.Search(ctx, agentName, opts)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("search_messages failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Format results
|
||||
resultMsgs := make([]map[string]any, len(resp.Results))
|
||||
for i, r := range resp.Results {
|
||||
entry := map[string]any{
|
||||
"message": r.Message,
|
||||
"match_type": r.MatchType,
|
||||
}
|
||||
if r.SimilarityScore > 0 {
|
||||
entry["similarity_score"] = r.SimilarityScore
|
||||
}
|
||||
if r.RelevanceScore > 0 {
|
||||
entry["relevance_score"] = r.RelevanceScore
|
||||
}
|
||||
resultMsgs[i] = entry
|
||||
}
|
||||
|
||||
result := map[string]any{
|
||||
"results": resultMsgs,
|
||||
"count": resp.TotalResults,
|
||||
"search_mode": resp.SearchMode,
|
||||
}
|
||||
if resp.Warning != "" {
|
||||
result["warning"] = resp.Warning
|
||||
}
|
||||
|
||||
return resultJSON(result)
|
||||
}
|
||||
|
||||
// Fallback: use messaging service directly (no search service configured)
|
||||
msgOpts := messaging.SearchOptions{
|
||||
Limit: req.GetInt("limit", 20),
|
||||
MinPriority: req.GetInt("min_priority", 0),
|
||||
FromAgent: req.GetString("from_agent", ""),
|
||||
Status: req.GetString("status", ""),
|
||||
}
|
||||
|
||||
messages, err := tr.msgService.SearchMessages(ctx, agentName, query, msgOpts)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("search_messages failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"messages": messages,
|
||||
"count": len(messages),
|
||||
"search_mode": "fulltext",
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleDiscoverAgents(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
query := req.GetString("query", "")
|
||||
_ = agentName // just verifying auth
|
||||
|
||||
agentsList, err := tr.agentService.DiscoverAgents(ctx, query)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("discover_agents failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Strip sensitive fields, exclude system agent
|
||||
result := make([]map[string]any, 0, len(agentsList))
|
||||
for _, a := range agentsList {
|
||||
if a.Name == "system" {
|
||||
continue
|
||||
}
|
||||
result = append(result, map[string]any{
|
||||
"name": a.Name,
|
||||
"display_name": a.DisplayName,
|
||||
"type": a.Type,
|
||||
"capabilities": a.Capabilities,
|
||||
"status": a.Status,
|
||||
})
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"agents": result,
|
||||
"count": len(result),
|
||||
})
|
||||
}
|
||||
|
||||
func (tr *ToolRegistrar) handleMyStatus(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
// 1. Get agent identity
|
||||
agent, err := tr.agentService.GetAgent(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Resolve owner name from users table
|
||||
ownerName := ""
|
||||
if tr.db != nil {
|
||||
var username sql.NullString
|
||||
_ = tr.db.QueryRowContext(ctx,
|
||||
`SELECT username FROM users WHERE id = ?`, agent.OwnerID,
|
||||
).Scan(&username)
|
||||
if username.Valid {
|
||||
ownerName = username.String
|
||||
}
|
||||
}
|
||||
|
||||
agentInfo := map[string]any{
|
||||
"name": agent.Name,
|
||||
"display_name": agent.DisplayName,
|
||||
"type": agent.Type,
|
||||
"owner": ownerName,
|
||||
}
|
||||
|
||||
// 2. Get pending DMs
|
||||
pendingDMs, err := tr.msgService.GetPendingDMs(ctx, agentName, 10)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
pendingDMCount, err := tr.msgService.GetPendingDMCount(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
dmList := make([]map[string]any, len(pendingDMs))
|
||||
for i, msg := range pendingDMs {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
entry := map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": body,
|
||||
"priority": msg.Priority,
|
||||
"status": msg.Status,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
// Include subject from conversation if available
|
||||
if msg.ConversationID > 0 {
|
||||
conv, _, _ := tr.msgService.GetConversation(ctx, msg.ConversationID)
|
||||
if conv != nil && conv.Subject != "" {
|
||||
entry["subject"] = conv.Subject
|
||||
}
|
||||
}
|
||||
dmList[i] = entry
|
||||
}
|
||||
|
||||
// 3. Get channel mentions
|
||||
mentions, err := tr.msgService.GetRecentMentions(ctx, agentName, 10)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
mentionList := make([]map[string]any, len(mentions))
|
||||
for i, msg := range mentions {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
entry := map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": body,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
// Try to extract channel name from metadata
|
||||
if len(msg.Metadata) > 0 {
|
||||
var meta map[string]any
|
||||
if json.Unmarshal(msg.Metadata, &meta) == nil {
|
||||
if chName, ok := meta["channel_name"].(string); ok {
|
||||
entry["channel"] = chName
|
||||
}
|
||||
}
|
||||
}
|
||||
mentionList[i] = entry
|
||||
}
|
||||
|
||||
// 4. Get system notifications
|
||||
sysNotifs, err := tr.msgService.GetSystemNotifications(ctx, agentName, 5)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
sysNotifList := make([]map[string]any, len(sysNotifs))
|
||||
for i, msg := range sysNotifs {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
sysNotifList[i] = map[string]any{
|
||||
"id": msg.ID,
|
||||
"body": body,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
// 5. Get channel summaries
|
||||
var channelSummaries []channels.ChannelSummary
|
||||
if tr.channelService != nil {
|
||||
channelSummaries, err = tr.channelService.GetChannelSummaries(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
}
|
||||
if channelSummaries == nil {
|
||||
channelSummaries = []channels.ChannelSummary{}
|
||||
}
|
||||
|
||||
// 6. Build stats
|
||||
totalUnreadChannel := 0
|
||||
for _, cs := range channelSummaries {
|
||||
totalUnreadChannel += cs.UnreadCount
|
||||
}
|
||||
|
||||
stats := map[string]any{
|
||||
"pending_dms": pendingDMCount,
|
||||
"channels_joined": len(channelSummaries),
|
||||
"unread_channel_messages": totalUnreadChannel,
|
||||
"system_notifications": len(sysNotifs),
|
||||
}
|
||||
|
||||
// 7. Build truncation instructions
|
||||
var instructionParts []string
|
||||
truncated := false
|
||||
if int64(len(pendingDMs)) < pendingDMCount {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d of %d pending messages. Use read_inbox to see all.", len(pendingDMs), pendingDMCount))
|
||||
}
|
||||
if len(mentions) >= 10 {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d mentions (may be more). Use search_messages to find all.", len(mentions)))
|
||||
}
|
||||
if len(sysNotifs) >= 5 {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d system notifications (may be more). Use read_inbox with from_agent='system' to see all.", len(sysNotifs)))
|
||||
}
|
||||
|
||||
result := map[string]any{
|
||||
"agent": agentInfo,
|
||||
"direct_messages": dmList,
|
||||
"direct_messages_total": pendingDMCount,
|
||||
"mentions": mentionList,
|
||||
"mentions_total": len(mentions),
|
||||
"system_notifications": sysNotifList,
|
||||
"system_notifications_total": len(sysNotifs),
|
||||
"channels": channelSummaries,
|
||||
"stats": stats,
|
||||
"truncated": truncated,
|
||||
}
|
||||
|
||||
if len(instructionParts) > 0 {
|
||||
result["instructions"] = strings.Join(instructionParts, " ")
|
||||
}
|
||||
|
||||
return resultJSON(result)
|
||||
}
|
||||
|
||||
// resultJSON marshals data to a JSON text MCP result.
|
||||
func resultJSON(data any) (*mcp.CallToolResult, error) {
|
||||
b, err := json.Marshal(data)
|
||||
|
||||
@@ -1,161 +0,0 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
)
|
||||
|
||||
// AttachmentToolRegistrar registers attachment MCP tools on the server.
|
||||
type AttachmentToolRegistrar struct {
|
||||
attachmentService *attachments.Service
|
||||
}
|
||||
|
||||
// NewAttachmentToolRegistrar creates a new attachment tool registrar.
|
||||
func NewAttachmentToolRegistrar(attachmentService *attachments.Service) *AttachmentToolRegistrar {
|
||||
return &AttachmentToolRegistrar{
|
||||
attachmentService: attachmentService,
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAll registers all attachment tools on the MCP server.
|
||||
func (atr *AttachmentToolRegistrar) RegisterAll(s *server.MCPServer) {
|
||||
s.AddTool(atr.uploadAttachmentTool(), atr.handleUploadAttachment)
|
||||
s.AddTool(atr.downloadAttachmentTool(), atr.handleDownloadAttachment)
|
||||
s.AddTool(atr.gcAttachmentsTool(), atr.handleGCAttachments)
|
||||
}
|
||||
|
||||
// --- Tool Definitions ---
|
||||
|
||||
func (atr *AttachmentToolRegistrar) uploadAttachmentTool() mcp.Tool {
|
||||
return mcp.NewTool("upload_attachment",
|
||||
mcp.WithDescription("Upload a file attachment. Content must be base64-encoded. Returns the SHA-256 hash for later retrieval. Max file size: 50MB."),
|
||||
mcp.WithString("content", mcp.Description("Base64-encoded file content"), mcp.Required()),
|
||||
mcp.WithString("filename", mcp.Description("Original filename (optional, used for MIME detection and display)")),
|
||||
mcp.WithString("mime_type", mcp.Description("MIME type override (optional, auto-detected from content if not provided)")),
|
||||
mcp.WithNumber("message_id", mcp.Description("Message ID to attach the file to (optional, can be linked later)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (atr *AttachmentToolRegistrar) downloadAttachmentTool() mcp.Tool {
|
||||
return mcp.NewTool("download_attachment",
|
||||
mcp.WithDescription("Download an attachment by its SHA-256 hash. Returns base64-encoded content along with filename and MIME type metadata."),
|
||||
mcp.WithString("hash", mcp.Description("SHA-256 hash of the attachment"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (atr *AttachmentToolRegistrar) gcAttachmentsTool() mcp.Tool {
|
||||
return mcp.NewTool("gc_attachments",
|
||||
mcp.WithDescription("Run garbage collection to remove orphaned attachments not referenced by any message. Returns a summary of files removed and bytes reclaimed."),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Tool Handlers ---
|
||||
|
||||
func (atr *AttachmentToolRegistrar) handleUploadAttachment(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
contentB64 := req.GetString("content", "")
|
||||
if contentB64 == "" {
|
||||
return mcp.NewToolResultError("'content' parameter is required"), nil
|
||||
}
|
||||
|
||||
// Check base64 size before decoding to avoid buffering oversized content.
|
||||
// Base64 expands data by ~4/3, so decoded size is roughly 3/4 of encoded.
|
||||
if int64(len(contentB64))*3/4 > attachments.MaxFileSize {
|
||||
return mcp.NewToolResultError("file exceeds maximum size of 50MB"), nil
|
||||
}
|
||||
|
||||
decoded, err := base64.StdEncoding.DecodeString(contentB64)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("invalid base64 content: %s", err)), nil
|
||||
}
|
||||
|
||||
if int64(len(decoded)) > attachments.MaxFileSize {
|
||||
return mcp.NewToolResultError("file exceeds maximum size of 50MB"), nil
|
||||
}
|
||||
|
||||
uploadReq := attachments.UploadRequest{
|
||||
Content: bytes.NewReader(decoded),
|
||||
Filename: req.GetString("filename", ""),
|
||||
MIMEType: req.GetString("mime_type", ""),
|
||||
UploadedBy: agentName,
|
||||
}
|
||||
|
||||
// Optional message_id.
|
||||
if mid := req.GetInt("message_id", 0); mid > 0 {
|
||||
v := int64(mid)
|
||||
uploadReq.MessageID = &v
|
||||
}
|
||||
|
||||
result, err := atr.attachmentService.Upload(ctx, uploadReq)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("upload_attachment failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"hash": result.Hash,
|
||||
"size": result.Size,
|
||||
"mime_type": result.MIMEType,
|
||||
"original_filename": result.Filename,
|
||||
})
|
||||
}
|
||||
|
||||
func (atr *AttachmentToolRegistrar) handleDownloadAttachment(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
_, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
hash := req.GetString("hash", "")
|
||||
if hash == "" {
|
||||
return mcp.NewToolResultError("'hash' parameter is required"), nil
|
||||
}
|
||||
|
||||
result, err := atr.attachmentService.Download(ctx, hash)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("download_attachment failed: %s", err)), nil
|
||||
}
|
||||
defer result.Content.Close()
|
||||
|
||||
// Read content and base64-encode it.
|
||||
content, err := io.ReadAll(result.Content)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("read attachment content failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"hash": result.Hash,
|
||||
"content": base64.StdEncoding.EncodeToString(content),
|
||||
"original_filename": result.Filename,
|
||||
"mime_type": result.MIMEType,
|
||||
"size": result.Size,
|
||||
})
|
||||
}
|
||||
|
||||
func (atr *AttachmentToolRegistrar) handleGCAttachments(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
_, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
result, err := atr.attachmentService.GarbageCollect(ctx)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("gc_attachments failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"files_removed": result.FilesRemoved,
|
||||
"bytes_reclaimed": result.BytesReclaimed,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,477 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/attachments"
|
||||
"github.com/synapbus/synapbus/internal/channels"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/search"
|
||||
)
|
||||
|
||||
// HybridToolRegistrar registers the 4 hybrid MCP tools.
|
||||
type HybridToolRegistrar struct {
|
||||
msgService *messaging.MessagingService
|
||||
agentService *agents.AgentService
|
||||
channelService *channels.Service
|
||||
swarmService *channels.SwarmService
|
||||
attachmentService *attachments.Service
|
||||
searchService *search.Service
|
||||
jsPool *jsruntime.Pool
|
||||
actionRegistry *actions.Registry
|
||||
actionIndex *actions.Index
|
||||
db *sql.DB
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewHybridToolRegistrar creates a new hybrid tool registrar.
|
||||
func NewHybridToolRegistrar(
|
||||
msgService *messaging.MessagingService,
|
||||
agentService *agents.AgentService,
|
||||
channelService *channels.Service,
|
||||
swarmService *channels.SwarmService,
|
||||
attachmentService *attachments.Service,
|
||||
searchService *search.Service,
|
||||
jsPool *jsruntime.Pool,
|
||||
actionRegistry *actions.Registry,
|
||||
actionIndex *actions.Index,
|
||||
db *sql.DB,
|
||||
) *HybridToolRegistrar {
|
||||
return &HybridToolRegistrar{
|
||||
msgService: msgService,
|
||||
agentService: agentService,
|
||||
channelService: channelService,
|
||||
swarmService: swarmService,
|
||||
attachmentService: attachmentService,
|
||||
searchService: searchService,
|
||||
jsPool: jsPool,
|
||||
actionRegistry: actionRegistry,
|
||||
actionIndex: actionIndex,
|
||||
db: db,
|
||||
logger: slog.Default().With("component", "mcp-hybrid-tools"),
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAllOnServer registers all 4 hybrid tools on an mcp-go MCPServer.
|
||||
func (h *HybridToolRegistrar) RegisterAllOnServer(s *server.MCPServer) {
|
||||
s.AddTool(h.myStatusTool(), h.handleMyStatus)
|
||||
s.AddTool(h.sendMessageTool(), h.handleSendMessage)
|
||||
s.AddTool(h.searchTool(), h.handleSearch)
|
||||
s.AddTool(h.executeTool(), h.handleExecute)
|
||||
|
||||
h.logger.Info("hybrid MCP tools registered", "count", 4)
|
||||
}
|
||||
|
||||
// --- Tool Definitions ---
|
||||
|
||||
func (h *HybridToolRegistrar) myStatusTool() mcplib.Tool {
|
||||
return mcplib.NewTool("my_status",
|
||||
mcplib.WithDescription("Get your complete status overview — identity, pending messages, channel mentions, system notifications, and statistics. Call this first when connecting to SynapBus."),
|
||||
)
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) sendMessageTool() mcplib.Tool {
|
||||
return mcplib.NewTool("send_message",
|
||||
mcplib.WithDescription("Send a message to another agent (DM) or to a channel. Specify exactly one of 'to' (agent name for DM) or 'channel' (channel name or numeric ID)."),
|
||||
mcplib.WithString("to", mcplib.Description("Recipient agent name for direct messages")),
|
||||
mcplib.WithString("channel", mcplib.Description("Channel name or numeric ID for channel messages")),
|
||||
mcplib.WithString("body", mcplib.Description("Message body text"), mcplib.Required()),
|
||||
mcplib.WithString("subject", mcplib.Description("Conversation subject (optional)")),
|
||||
mcplib.WithNumber("priority", mcplib.Description("Message priority (1-10, default 5)"), mcplib.Min(1), mcplib.Max(10)),
|
||||
mcplib.WithString("metadata", mcplib.Description("JSON metadata object (optional)")),
|
||||
mcplib.WithNumber("reply_to", mcplib.Description("ID of the message to reply to (optional, for threading)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) searchTool() mcplib.Tool {
|
||||
return mcplib.NewTool("search",
|
||||
mcplib.WithDescription("Search for available actions you can perform via the 'execute' tool. Returns action names, descriptions, parameters, and examples. Use an empty query to browse all actions, or describe what you want to do."),
|
||||
mcplib.WithString("query", mcplib.Description("What you want to do — e.g. 'read messages', 'create channel', 'upload file'")),
|
||||
mcplib.WithNumber("limit", mcplib.Description("Maximum results to return (default 5, max 20)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) executeTool() mcplib.Tool {
|
||||
return mcplib.NewTool("execute",
|
||||
mcplib.WithDescription("Execute code that calls SynapBus actions. Use call(actionName, args) to invoke actions discovered via the 'search' tool. Multiple sequential calls are supported."),
|
||||
mcplib.WithString("code", mcplib.Description("Code containing call() expressions. Example: call('read_inbox', { limit: 5 })"), mcplib.Required()),
|
||||
mcplib.WithNumber("timeout", mcplib.Description("Execution timeout in milliseconds (default 120000, max 300000)")),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Tool Handlers ---
|
||||
|
||||
func (h *HybridToolRegistrar) handleMyStatus(ctx context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcplib.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
// 1. Get agent identity.
|
||||
agent, err := h.agentService.GetAgent(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
// Resolve owner name.
|
||||
ownerName := ""
|
||||
if h.db != nil {
|
||||
var username sql.NullString
|
||||
_ = h.db.QueryRowContext(ctx,
|
||||
`SELECT username FROM users WHERE id = ?`, agent.OwnerID,
|
||||
).Scan(&username)
|
||||
if username.Valid {
|
||||
ownerName = username.String
|
||||
}
|
||||
}
|
||||
|
||||
agentInfo := map[string]any{
|
||||
"name": agent.Name,
|
||||
"display_name": agent.DisplayName,
|
||||
"type": agent.Type,
|
||||
"owner": ownerName,
|
||||
}
|
||||
|
||||
// 2. Get pending DMs.
|
||||
pendingDMs, err := h.msgService.GetPendingDMs(ctx, agentName, 10)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
pendingDMCount, err := h.msgService.GetPendingDMCount(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
dmList := make([]map[string]any, len(pendingDMs))
|
||||
for i, msg := range pendingDMs {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
entry := map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": body,
|
||||
"priority": msg.Priority,
|
||||
"status": msg.Status,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
if msg.ConversationID > 0 {
|
||||
conv, _, _ := h.msgService.GetConversation(ctx, msg.ConversationID)
|
||||
if conv != nil && conv.Subject != "" {
|
||||
entry["subject"] = conv.Subject
|
||||
}
|
||||
}
|
||||
dmList[i] = entry
|
||||
}
|
||||
|
||||
// 3. Get channel mentions.
|
||||
mentions, err := h.msgService.GetRecentMentions(ctx, agentName, 10)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
mentionList := make([]map[string]any, len(mentions))
|
||||
for i, msg := range mentions {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
entry := map[string]any{
|
||||
"id": msg.ID,
|
||||
"from": msg.FromAgent,
|
||||
"body": body,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
if len(msg.Metadata) > 0 {
|
||||
var meta map[string]any
|
||||
if json.Unmarshal(msg.Metadata, &meta) == nil {
|
||||
if chName, ok := meta["channel_name"].(string); ok {
|
||||
entry["channel"] = chName
|
||||
}
|
||||
}
|
||||
}
|
||||
mentionList[i] = entry
|
||||
}
|
||||
|
||||
// 4. Get system notifications.
|
||||
sysNotifs, err := h.msgService.GetSystemNotifications(ctx, agentName, 5)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
|
||||
sysNotifList := make([]map[string]any, len(sysNotifs))
|
||||
for i, msg := range sysNotifs {
|
||||
body := msg.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "..."
|
||||
}
|
||||
sysNotifList[i] = map[string]any{
|
||||
"id": msg.ID,
|
||||
"body": body,
|
||||
"created_at": msg.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
// 5. Get channel summaries.
|
||||
var channelSummaries []channels.ChannelSummary
|
||||
if h.channelService != nil {
|
||||
channelSummaries, err = h.channelService.GetChannelSummaries(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("my_status failed: %s", err)), nil
|
||||
}
|
||||
}
|
||||
if channelSummaries == nil {
|
||||
channelSummaries = []channels.ChannelSummary{}
|
||||
}
|
||||
|
||||
// 6. Build stats.
|
||||
totalUnreadChannel := 0
|
||||
for _, cs := range channelSummaries {
|
||||
totalUnreadChannel += cs.UnreadCount
|
||||
}
|
||||
|
||||
stats := map[string]any{
|
||||
"pending_dms": pendingDMCount,
|
||||
"channels_joined": len(channelSummaries),
|
||||
"unread_channel_messages": totalUnreadChannel,
|
||||
"system_notifications": len(sysNotifs),
|
||||
}
|
||||
|
||||
// 7. Build truncation instructions.
|
||||
var instructionParts []string
|
||||
truncated := false
|
||||
if int64(len(pendingDMs)) < pendingDMCount {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d of %d pending messages. Use execute tool with call('read_inbox', {}) to see all.", len(pendingDMs), pendingDMCount))
|
||||
}
|
||||
if len(mentions) >= 10 {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d mentions (may be more). Use execute tool with call('search_messages', {}) to find all.", len(mentions)))
|
||||
}
|
||||
if len(sysNotifs) >= 5 {
|
||||
truncated = true
|
||||
instructionParts = append(instructionParts, fmt.Sprintf("Showing %d system notifications (may be more). Use execute tool with call('read_inbox', { from_agent: 'system' }) to see all.", len(sysNotifs)))
|
||||
}
|
||||
|
||||
// 8. Add usage instructions for the hybrid tools.
|
||||
usageInstructions := "Use 'search' tool with a query to discover available actions. " +
|
||||
"Use 'execute' tool with call(action, args) to perform any action. " +
|
||||
"Use 'send_message' tool directly for sending messages (DMs or channel)."
|
||||
|
||||
result := map[string]any{
|
||||
"agent": agentInfo,
|
||||
"direct_messages": dmList,
|
||||
"direct_messages_total": pendingDMCount,
|
||||
"mentions": mentionList,
|
||||
"mentions_total": len(mentions),
|
||||
"system_notifications": sysNotifList,
|
||||
"system_notifications_total": len(sysNotifs),
|
||||
"channels": channelSummaries,
|
||||
"stats": stats,
|
||||
"truncated": truncated,
|
||||
"usage": usageInstructions,
|
||||
}
|
||||
|
||||
if len(instructionParts) > 0 {
|
||||
result["instructions"] = strings.Join(instructionParts, " ")
|
||||
}
|
||||
|
||||
return resultJSON(result)
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) handleSendMessage(ctx context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcplib.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
to := req.GetString("to", "")
|
||||
channel := req.GetString("channel", "")
|
||||
body := req.GetString("body", "")
|
||||
subject := req.GetString("subject", "")
|
||||
priority := req.GetInt("priority", 5)
|
||||
metadataStr := req.GetString("metadata", "")
|
||||
|
||||
if body == "" {
|
||||
return mcplib.NewToolResultError("'body' parameter is required"), nil
|
||||
}
|
||||
|
||||
// Validate mutually exclusive: exactly one of to/channel.
|
||||
if to == "" && channel == "" {
|
||||
return mcplib.NewToolResultError("either 'to' (agent name) or 'channel' (channel name/ID) is required"), nil
|
||||
}
|
||||
if to != "" && channel != "" {
|
||||
return mcplib.NewToolResultError("specify exactly one of 'to' (for DM) or 'channel' (for channel message), not both"), nil
|
||||
}
|
||||
|
||||
var replyTo *int64
|
||||
if rtID := req.GetInt("reply_to", 0); rtID > 0 {
|
||||
v := int64(rtID)
|
||||
replyTo = &v
|
||||
}
|
||||
|
||||
// Channel message path.
|
||||
if channel != "" {
|
||||
if h.channelService == nil {
|
||||
return mcplib.NewToolResultError("channel service not available"), nil
|
||||
}
|
||||
|
||||
// Resolve channel by name or numeric ID.
|
||||
channelID, err := h.resolveChannel(ctx, channel)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("send_message to channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
messages, err := h.channelService.BroadcastMessage(ctx, channelID, agentName, body, priority, metadataStr, replyTo)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("send_message to channel failed: %s", err)), nil
|
||||
}
|
||||
|
||||
var messageID int64
|
||||
if len(messages) > 0 {
|
||||
messageID = messages[0].ID
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"channel_id": channelID,
|
||||
"message_id": messageID,
|
||||
"status": "sent",
|
||||
})
|
||||
}
|
||||
|
||||
// DM path.
|
||||
opts := messaging.SendOptions{
|
||||
Subject: subject,
|
||||
Priority: priority,
|
||||
Metadata: metadataStr,
|
||||
ReplyTo: replyTo,
|
||||
}
|
||||
|
||||
msg, err := h.msgService.SendMessage(ctx, agentName, to, body, opts)
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("send_message failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"message_id": msg.ID,
|
||||
"conversation_id": msg.ConversationID,
|
||||
"status": msg.Status,
|
||||
})
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) handleSearch(ctx context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
|
||||
_, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcplib.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
query := req.GetString("query", "")
|
||||
limit := req.GetInt("limit", 5)
|
||||
|
||||
results := h.actionIndex.Search(query, limit)
|
||||
|
||||
// Format results for the agent.
|
||||
formatted := make([]map[string]any, len(results))
|
||||
for i, r := range results {
|
||||
params := make([]map[string]any, len(r.Action.Params))
|
||||
for j, p := range r.Action.Params {
|
||||
params[j] = map[string]any{
|
||||
"name": p.Name,
|
||||
"type": p.Type,
|
||||
"description": p.Description,
|
||||
"required": p.Required,
|
||||
}
|
||||
}
|
||||
|
||||
entry := map[string]any{
|
||||
"name": r.Action.Name,
|
||||
"category": r.Action.Category,
|
||||
"description": r.Action.Description,
|
||||
"params": params,
|
||||
"examples": r.Action.Examples,
|
||||
}
|
||||
if r.Score > 0 {
|
||||
entry["relevance_score"] = r.Score
|
||||
}
|
||||
formatted[i] = entry
|
||||
}
|
||||
|
||||
result := map[string]any{
|
||||
"actions": formatted,
|
||||
"count": len(formatted),
|
||||
"note": "Use the 'execute' tool with call(actionName, { param: value }) to run any action.",
|
||||
}
|
||||
|
||||
return resultJSON(result)
|
||||
}
|
||||
|
||||
func (h *HybridToolRegistrar) handleExecute(ctx context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcplib.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
code := req.GetString("code", "")
|
||||
if code == "" {
|
||||
return mcplib.NewToolResultError("'code' parameter is required"), nil
|
||||
}
|
||||
|
||||
timeoutMs := req.GetInt("timeout", 120000)
|
||||
if timeoutMs > 300000 {
|
||||
timeoutMs = 300000
|
||||
}
|
||||
timeout := time.Duration(timeoutMs) * time.Millisecond
|
||||
|
||||
// Create a bridge for this agent.
|
||||
bridge := NewServiceBridge(
|
||||
h.msgService,
|
||||
h.agentService,
|
||||
h.channelService,
|
||||
h.swarmService,
|
||||
h.attachmentService,
|
||||
h.searchService,
|
||||
agentName,
|
||||
)
|
||||
|
||||
result, err := h.jsPool.Execute(ctx, code, bridge, jsruntime.ExecuteOptions{
|
||||
Timeout: timeout,
|
||||
})
|
||||
if err != nil {
|
||||
return mcplib.NewToolResultError(fmt.Sprintf("execute failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"result": result.Value,
|
||||
"calls": result.CallCount,
|
||||
"duration": result.Duration.String(),
|
||||
})
|
||||
}
|
||||
|
||||
// resolveChannel resolves a channel name or numeric ID string to an int64 channel ID.
|
||||
func (h *HybridToolRegistrar) resolveChannel(ctx context.Context, channel string) (int64, error) {
|
||||
// Try parsing as numeric ID first.
|
||||
var channelID int64
|
||||
if _, err := fmt.Sscanf(channel, "%d", &channelID); err == nil && channelID > 0 {
|
||||
return channelID, nil
|
||||
}
|
||||
|
||||
// Resolve by name.
|
||||
ch, err := h.channelService.GetChannelByName(ctx, channel)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return ch.ID, nil
|
||||
}
|
||||
+242
-146
@@ -10,7 +10,9 @@ import (
|
||||
mcplib "github.com/mark3labs/mcp-go/mcp"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/actions"
|
||||
"github.com/synapbus/synapbus/internal/agents"
|
||||
"github.com/synapbus/synapbus/internal/jsruntime"
|
||||
"github.com/synapbus/synapbus/internal/messaging"
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
@@ -40,7 +42,7 @@ func newTestDB(t *testing.T) *sql.DB {
|
||||
return db
|
||||
}
|
||||
|
||||
func newTestRegistrar(t *testing.T) (*ToolRegistrar, *messaging.MessagingService, *agents.AgentService, *sql.DB) {
|
||||
func newTestHybridRegistrar(t *testing.T) (*HybridToolRegistrar, *messaging.MessagingService, *agents.AgentService, *sql.DB) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
@@ -53,7 +55,24 @@ func newTestRegistrar(t *testing.T) (*ToolRegistrar, *messaging.MessagingService
|
||||
agentStore := agents.NewSQLiteAgentStore(db)
|
||||
agentService := agents.NewAgentService(agentStore, tracer)
|
||||
|
||||
registrar := NewToolRegistrar(msgService, agentService)
|
||||
jsPool := jsruntime.NewPool(2)
|
||||
t.Cleanup(func() { jsPool.Close() })
|
||||
|
||||
actionRegistry := actions.NewRegistry()
|
||||
actionIndex := actions.NewIndex(actionRegistry.List())
|
||||
|
||||
registrar := NewHybridToolRegistrar(
|
||||
msgService,
|
||||
agentService,
|
||||
nil, // channelService
|
||||
nil, // swarmService
|
||||
nil, // attachmentService
|
||||
nil, // searchService
|
||||
jsPool,
|
||||
actionRegistry,
|
||||
actionIndex,
|
||||
db,
|
||||
)
|
||||
return registrar, msgService, agentService, db
|
||||
}
|
||||
|
||||
@@ -65,24 +84,67 @@ func makeRequest(args map[string]any) mcplib.CallToolRequest {
|
||||
}
|
||||
}
|
||||
|
||||
func TestToolHandler_SendMessage(t *testing.T) {
|
||||
tr, _, agentSvc, _ := newTestRegistrar(t)
|
||||
func TestHybridTool_MyStatus(t *testing.T) {
|
||||
h, _, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "test-agent", "Test Agent", "ai", nil, 1)
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "test-agent")
|
||||
|
||||
t.Run("returns status with usage instructions", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
|
||||
result, err := h.handleMyStatus(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleMyStatus: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
|
||||
// Check agent info
|
||||
agentInfo := resp["agent"].(map[string]any)
|
||||
if agentInfo["name"] != "test-agent" {
|
||||
t.Errorf("agent name = %v, want test-agent", agentInfo["name"])
|
||||
}
|
||||
|
||||
// Check usage instructions
|
||||
usage := resp["usage"].(string)
|
||||
if usage == "" {
|
||||
t.Error("expected usage instructions in response")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unauthenticated", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
result, _ := h.handleMyStatus(ctx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for unauthenticated request")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestHybridTool_SendMessage_DM(t *testing.T) {
|
||||
h, _, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Register agents
|
||||
agentSvc.Register(ctx, "sender", "Sender", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "receiver", "Receiver", "ai", nil, 1)
|
||||
|
||||
// Set up authenticated context
|
||||
authCtx := ContextWithAgentName(ctx, "sender")
|
||||
|
||||
t.Run("successful send", func(t *testing.T) {
|
||||
t.Run("successful DM", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"to": "receiver",
|
||||
"body": "Hello from test",
|
||||
})
|
||||
|
||||
result, err := tr.handleSendMessage(authCtx, req)
|
||||
result, err := h.handleSendMessage(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSendMessage: %v", err)
|
||||
}
|
||||
@@ -98,58 +160,65 @@ func TestToolHandler_SendMessage(t *testing.T) {
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing to", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"body": "no recipient",
|
||||
})
|
||||
|
||||
result, _ := tr.handleSendMessage(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for missing 'to'")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing body", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"to": "receiver",
|
||||
})
|
||||
|
||||
result, _ := tr.handleSendMessage(authCtx, req)
|
||||
result, _ := h.handleSendMessage(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for missing body")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("both to and channel rejected", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"to": "receiver",
|
||||
"channel": "general",
|
||||
"body": "test",
|
||||
})
|
||||
result, _ := h.handleSendMessage(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error when both to and channel specified")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("neither to nor channel rejected", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"body": "test",
|
||||
})
|
||||
result, _ := h.handleSendMessage(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error when neither to nor channel specified")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unauthenticated", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"to": "receiver",
|
||||
"body": "should fail",
|
||||
})
|
||||
|
||||
result, _ := tr.handleSendMessage(ctx, req)
|
||||
result, _ := h.handleSendMessage(ctx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for unauthenticated request")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestToolHandler_ReadInbox(t *testing.T) {
|
||||
tr, msgSvc, agentSvc, _ := newTestRegistrar(t)
|
||||
func TestHybridTool_Search(t *testing.T) {
|
||||
h, _, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "sender", "Sender", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "reader", "Reader", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "test-agent", "Test Agent", "ai", nil, 1)
|
||||
authCtx := ContextWithAgentName(ctx, "test-agent")
|
||||
|
||||
msgSvc.SendMessage(ctx, "sender", "reader", "test message", messaging.SendOptions{})
|
||||
t.Run("search for messaging actions", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"query": "read inbox messages",
|
||||
})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "reader")
|
||||
|
||||
t.Run("read messages", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
|
||||
result, err := tr.handleReadInbox(authCtx, req)
|
||||
result, err := h.handleSearch(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleReadInbox: %v", err)
|
||||
t.Fatalf("handleSearch: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
@@ -158,139 +227,166 @@ func TestToolHandler_ReadInbox(t *testing.T) {
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
|
||||
count := resp["count"].(float64)
|
||||
if count == 0 {
|
||||
t.Error("expected at least one result")
|
||||
}
|
||||
|
||||
actionsList := resp["actions"].([]any)
|
||||
firstAction := actionsList[0].(map[string]any)
|
||||
if firstAction["name"] == nil {
|
||||
t.Error("expected name in action result")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty query returns all actions", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"limit": float64(20),
|
||||
})
|
||||
|
||||
result, err := h.handleSearch(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSearch: %v", err)
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
|
||||
count := resp["count"].(float64)
|
||||
if count < 5 {
|
||||
t.Errorf("expected at least 5 actions in browse mode, got %v", count)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestHybridTool_Execute(t *testing.T) {
|
||||
h, msgSvc, agentSvc, _ := newTestHybridRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "executor", "Executor", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "target", "Target", "ai", nil, 1)
|
||||
|
||||
// Send a message so the executor has something to read
|
||||
msgSvc.SendMessage(ctx, "target", "executor", "hello executor", messaging.SendOptions{})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "executor")
|
||||
|
||||
t.Run("read_inbox via execute", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("read_inbox", { limit: 10 })`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
count := resultData["count"].(float64)
|
||||
if count != 1 {
|
||||
t.Errorf("count = %v, want 1", count)
|
||||
t.Errorf("expected 1 message, got %v", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("send_message via execute", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("send_message", { to: "target", body: "hello from execute" })`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
if resultData["message_id"] == nil {
|
||||
t.Error("expected message_id in execute result")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("discover_agents via execute", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("discover_agents", {})`,
|
||||
})
|
||||
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
resultData := parseCallResult(t, result)
|
||||
count := resultData["count"].(float64)
|
||||
if count < 2 {
|
||||
t.Errorf("expected at least 2 agents, got %v", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unknown action returns error", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("nonexistent_action", {})`,
|
||||
})
|
||||
|
||||
result, _ := h.handleExecute(authCtx, req)
|
||||
// call() returns { ok: false, error: {...} } inside a successful execution result.
|
||||
resp := parseResponse(t, result)
|
||||
callResult := resp["result"].(map[string]any)
|
||||
if callResult["ok"] != false {
|
||||
t.Error("expected ok=false for unknown action")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty code rejected", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"code": "",
|
||||
})
|
||||
|
||||
result, _ := h.handleExecute(authCtx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for empty code")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unauthenticated", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{})
|
||||
result, _ := tr.handleReadInbox(ctx, req)
|
||||
req := makeRequest(map[string]any{
|
||||
"code": `call("read_inbox", {})`,
|
||||
})
|
||||
result, _ := h.handleExecute(ctx, req)
|
||||
if !result.IsError {
|
||||
t.Error("expected error for unauthenticated request")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestToolHandler_ClaimMessages(t *testing.T) {
|
||||
tr, msgSvc, agentSvc, _ := newTestRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "sender", "Sender", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "claimer", "Claimer", "ai", nil, 1)
|
||||
|
||||
msgSvc.SendMessage(ctx, "sender", "claimer", "task 1", messaging.SendOptions{})
|
||||
msgSvc.SendMessage(ctx, "sender", "claimer", "task 2", messaging.SendOptions{})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "claimer")
|
||||
|
||||
req := makeRequest(map[string]any{"limit": float64(1)})
|
||||
result, err := tr.handleClaimMessages(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleClaimMessages: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
count := resp["count"].(float64)
|
||||
if count != 1 {
|
||||
t.Errorf("count = %v, want 1", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestToolHandler_MarkDone(t *testing.T) {
|
||||
tr, msgSvc, agentSvc, _ := newTestRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "sender", "Sender", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "worker", "Worker", "ai", nil, 1)
|
||||
|
||||
msg, _ := msgSvc.SendMessage(ctx, "sender", "worker", "do this", messaging.SendOptions{})
|
||||
msgSvc.ClaimMessages(ctx, "worker", 1)
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "worker")
|
||||
|
||||
req := makeRequest(map[string]any{
|
||||
"message_id": float64(msg.ID),
|
||||
})
|
||||
|
||||
result, err := tr.handleMarkDone(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleMarkDone: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
}
|
||||
|
||||
func TestToolHandler_SearchMessages(t *testing.T) {
|
||||
tr, msgSvc, agentSvc, _ := newTestRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "sender", "Sender", "ai", nil, 1)
|
||||
agentSvc.Register(ctx, "searcher", "Searcher", "ai", nil, 1)
|
||||
|
||||
msgSvc.SendMessage(ctx, "sender", "searcher", "deployment failed", messaging.SendOptions{})
|
||||
msgSvc.SendMessage(ctx, "sender", "searcher", "all clear", messaging.SendOptions{})
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "searcher")
|
||||
|
||||
t.Run("keyword search", func(t *testing.T) {
|
||||
t.Run("auth propagation to bridge", func(t *testing.T) {
|
||||
req := makeRequest(map[string]any{
|
||||
"query": "deployment",
|
||||
"code": `call("read_inbox", {})`,
|
||||
})
|
||||
|
||||
result, err := tr.handleSearchMessages(authCtx, req)
|
||||
// Execute as "executor" - should see executor's inbox
|
||||
result, err := h.handleExecute(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleSearchMessages: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
t.Fatalf("handleExecute: %v", err)
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
count := resp["count"].(float64)
|
||||
if count != 1 {
|
||||
t.Errorf("count = %v, want 1", count)
|
||||
|
||||
// The bridge should use "executor" as the agent name
|
||||
if resp["calls"].(float64) != 1 {
|
||||
t.Errorf("expected 1 call, got %v", resp["calls"])
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestToolHandler_DiscoverAgents(t *testing.T) {
|
||||
tr, _, agentSvc, _ := newTestRegistrar(t)
|
||||
ctx := context.Background()
|
||||
|
||||
agentSvc.Register(ctx, "bot-a", "Bot A", "ai", json.RawMessage(`{"skills":["search"]}`), 1)
|
||||
agentSvc.Register(ctx, "bot-b", "Bot B", "ai", json.RawMessage(`{"skills":["analyze"]}`), 1)
|
||||
|
||||
authCtx := ContextWithAgentName(ctx, "bot-a")
|
||||
|
||||
req := makeRequest(map[string]any{
|
||||
"query": "search",
|
||||
})
|
||||
|
||||
result, err := tr.handleDiscoverAgents(authCtx, req)
|
||||
if err != nil {
|
||||
t.Fatalf("handleDiscoverAgents: %v", err)
|
||||
}
|
||||
if result.IsError {
|
||||
t.Fatalf("unexpected error: %v", result.Content)
|
||||
}
|
||||
|
||||
var resp map[string]any
|
||||
text := result.Content[0].(mcplib.TextContent).Text
|
||||
json.Unmarshal([]byte(text), &resp)
|
||||
count := resp["count"].(float64)
|
||||
if count != 1 {
|
||||
t.Errorf("count = %v, want 1", count)
|
||||
}
|
||||
}
|
||||
|
||||
var _ = storage.RunMigrations
|
||||
|
||||
@@ -1,316 +0,0 @@
|
||||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/k8s"
|
||||
"github.com/synapbus/synapbus/internal/webhooks"
|
||||
)
|
||||
|
||||
// WebhookToolRegistrar registers webhook and K8s handler MCP tools.
|
||||
type WebhookToolRegistrar struct {
|
||||
webhookService *webhooks.WebhookService
|
||||
k8sService *k8s.K8sService
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewWebhookToolRegistrar creates a new webhook tool registrar.
|
||||
func NewWebhookToolRegistrar(webhookService *webhooks.WebhookService, k8sService *k8s.K8sService) *WebhookToolRegistrar {
|
||||
return &WebhookToolRegistrar{
|
||||
webhookService: webhookService,
|
||||
k8sService: k8sService,
|
||||
logger: slog.Default().With("component", "mcp-webhook-tools"),
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterAll registers all webhook and K8s handler tools on the MCP server.
|
||||
func (r *WebhookToolRegistrar) RegisterAll(s *server.MCPServer) {
|
||||
count := 0
|
||||
|
||||
// Webhook tools
|
||||
if r.webhookService != nil {
|
||||
s.AddTool(r.registerWebhookTool(), r.handleRegisterWebhook)
|
||||
s.AddTool(r.listWebhooksTool(), r.handleListWebhooks)
|
||||
s.AddTool(r.deleteWebhookTool(), r.handleDeleteWebhook)
|
||||
count += 3
|
||||
}
|
||||
|
||||
// K8s handler tools
|
||||
if r.k8sService != nil {
|
||||
s.AddTool(r.registerK8sHandlerTool(), r.handleRegisterK8sHandler)
|
||||
s.AddTool(r.listK8sHandlersTool(), r.handleListK8sHandlers)
|
||||
s.AddTool(r.deleteK8sHandlerTool(), r.handleDeleteK8sHandler)
|
||||
count += 3
|
||||
}
|
||||
|
||||
r.logger.Info("webhook/K8s MCP tools registered", "count", count)
|
||||
}
|
||||
|
||||
// --- Webhook Tool Definitions ---
|
||||
|
||||
func (r *WebhookToolRegistrar) registerWebhookTool() mcp.Tool {
|
||||
return mcp.NewTool("register_webhook",
|
||||
mcp.WithDescription("Register a webhook URL to receive event notifications. When matching events occur (messages, mentions), SynapBus will POST a signed JSON payload to your URL. Max 3 webhooks per agent. HTTPS required in production."),
|
||||
mcp.WithString("url", mcp.Description("HTTPS URL to receive webhook POST requests"), mcp.Required()),
|
||||
mcp.WithString("events", mcp.Description("Comma-separated event types: message.received, message.mentioned, channel.message"), mcp.Required()),
|
||||
mcp.WithString("secret", mcp.Description("Shared secret for HMAC-SHA256 payload signing (X-SynapBus-Signature header)"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) listWebhooksTool() mcp.Tool {
|
||||
return mcp.NewTool("list_webhooks",
|
||||
mcp.WithDescription("List your registered webhooks and their status (active/disabled, failure counts)."),
|
||||
)
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) deleteWebhookTool() mcp.Tool {
|
||||
return mcp.NewTool("delete_webhook",
|
||||
mcp.WithDescription("Delete one of your registered webhooks by ID."),
|
||||
mcp.WithNumber("webhook_id", mcp.Description("ID of the webhook to delete"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
// --- Webhook Tool Handlers ---
|
||||
|
||||
func (r *WebhookToolRegistrar) handleRegisterWebhook(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
url := req.GetString("url", "")
|
||||
eventsStr := req.GetString("events", "")
|
||||
secret := req.GetString("secret", "")
|
||||
|
||||
if url == "" {
|
||||
return mcp.NewToolResultError("'url' parameter is required"), nil
|
||||
}
|
||||
if eventsStr == "" {
|
||||
return mcp.NewToolResultError("'events' parameter is required"), nil
|
||||
}
|
||||
if secret == "" {
|
||||
return mcp.NewToolResultError("'secret' parameter is required"), nil
|
||||
}
|
||||
|
||||
// Parse comma-separated events
|
||||
events := parseEvents(eventsStr)
|
||||
|
||||
wh, err := r.webhookService.RegisterWebhook(ctx, agentName, url, events, secret)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("register_webhook failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"webhook_id": wh.ID,
|
||||
"url": wh.URL,
|
||||
"events": wh.Events,
|
||||
"status": wh.Status,
|
||||
})
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) handleListWebhooks(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
hooks, err := r.webhookService.ListWebhooks(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_webhooks failed: %s", err)), nil
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(hooks))
|
||||
for i, wh := range hooks {
|
||||
result[i] = map[string]any{
|
||||
"id": wh.ID,
|
||||
"url": wh.URL,
|
||||
"events": wh.Events,
|
||||
"status": wh.Status,
|
||||
"consecutive_failures": wh.ConsecutiveFailures,
|
||||
"created_at": wh.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"webhooks": result,
|
||||
"count": len(result),
|
||||
})
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) handleDeleteWebhook(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
webhookID, err := req.RequireInt("webhook_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'webhook_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := r.webhookService.DeleteWebhook(ctx, agentName, int64(webhookID)); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("delete_webhook failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"deleted": true,
|
||||
"webhook_id": webhookID,
|
||||
})
|
||||
}
|
||||
|
||||
// --- K8s Handler Tool Definitions ---
|
||||
|
||||
func (r *WebhookToolRegistrar) registerK8sHandlerTool() mcp.Tool {
|
||||
return mcp.NewTool("register_k8s_handler",
|
||||
mcp.WithDescription("Register a Kubernetes Job handler. When matching events occur, SynapBus launches a K8s Job with message data injected via environment variables. Only available when SynapBus runs in-cluster."),
|
||||
mcp.WithString("image", mcp.Description("Container image to run (e.g. myregistry/handler:v1)"), mcp.Required()),
|
||||
mcp.WithString("events", mcp.Description("Comma-separated event types: message.received, message.mentioned, channel.message"), mcp.Required()),
|
||||
mcp.WithString("namespace", mcp.Description("Kubernetes namespace (default: SynapBus's namespace)")),
|
||||
mcp.WithString("resources_memory", mcp.Description("Memory limit (e.g. 256Mi, 1Gi)")),
|
||||
mcp.WithString("resources_cpu", mcp.Description("CPU limit (e.g. 100m, 1)")),
|
||||
mcp.WithString("env", mcp.Description("Comma-separated KEY=VALUE environment variables")),
|
||||
mcp.WithNumber("timeout_seconds", mcp.Description("Job timeout in seconds (default 300)")),
|
||||
)
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) listK8sHandlersTool() mcp.Tool {
|
||||
return mcp.NewTool("list_k8s_handlers",
|
||||
mcp.WithDescription("List your registered Kubernetes Job handlers and their status."),
|
||||
)
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) deleteK8sHandlerTool() mcp.Tool {
|
||||
return mcp.NewTool("delete_k8s_handler",
|
||||
mcp.WithDescription("Delete one of your registered Kubernetes Job handlers by ID."),
|
||||
mcp.WithNumber("handler_id", mcp.Description("ID of the K8s handler to delete"), mcp.Required()),
|
||||
)
|
||||
}
|
||||
|
||||
// --- K8s Handler Tool Handlers ---
|
||||
|
||||
func (r *WebhookToolRegistrar) handleRegisterK8sHandler(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
image := req.GetString("image", "")
|
||||
eventsStr := req.GetString("events", "")
|
||||
|
||||
if image == "" {
|
||||
return mcp.NewToolResultError("'image' parameter is required"), nil
|
||||
}
|
||||
if eventsStr == "" {
|
||||
return mcp.NewToolResultError("'events' parameter is required"), nil
|
||||
}
|
||||
|
||||
events := parseEvents(eventsStr)
|
||||
|
||||
// Parse env vars
|
||||
envMap := make(map[string]string)
|
||||
if envStr := req.GetString("env", ""); envStr != "" {
|
||||
for _, pair := range strings.Split(envStr, ",") {
|
||||
pair = strings.TrimSpace(pair)
|
||||
if parts := strings.SplitN(pair, "=", 2); len(parts) == 2 {
|
||||
envMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
handlerReq := k8s.RegisterHandlerRequest{
|
||||
Image: image,
|
||||
Events: events,
|
||||
Namespace: req.GetString("namespace", ""),
|
||||
ResourcesMemory: req.GetString("resources_memory", ""),
|
||||
ResourcesCPU: req.GetString("resources_cpu", ""),
|
||||
Env: envMap,
|
||||
TimeoutSeconds: req.GetInt("timeout_seconds", 300),
|
||||
}
|
||||
|
||||
handler, err := r.k8sService.RegisterHandler(ctx, agentName, handlerReq)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("register_k8s_handler failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"handler_id": handler.ID,
|
||||
"image": handler.Image,
|
||||
"events": handler.Events,
|
||||
"namespace": handler.Namespace,
|
||||
"timeout_seconds": handler.TimeoutSeconds,
|
||||
"status": handler.Status,
|
||||
})
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) handleListK8sHandlers(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
handlers, err := r.k8sService.ListHandlers(ctx, agentName)
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("list_k8s_handlers failed: %s", err)), nil
|
||||
}
|
||||
|
||||
result := make([]map[string]any, len(handlers))
|
||||
for i, h := range handlers {
|
||||
result[i] = map[string]any{
|
||||
"id": h.ID,
|
||||
"image": h.Image,
|
||||
"events": h.Events,
|
||||
"namespace": h.Namespace,
|
||||
"resources_memory": h.ResourcesMemory,
|
||||
"resources_cpu": h.ResourcesCPU,
|
||||
"timeout_seconds": h.TimeoutSeconds,
|
||||
"status": h.Status,
|
||||
"created_at": h.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"handlers": result,
|
||||
"count": len(result),
|
||||
"k8s_available": r.k8sService.IsAvailable(),
|
||||
})
|
||||
}
|
||||
|
||||
func (r *WebhookToolRegistrar) handleDeleteK8sHandler(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
agentName, ok := extractAgentName(ctx)
|
||||
if !ok {
|
||||
return mcp.NewToolResultError("authentication required"), nil
|
||||
}
|
||||
|
||||
handlerID, err := req.RequireInt("handler_id")
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("'handler_id' parameter is required"), nil
|
||||
}
|
||||
|
||||
if err := r.k8sService.DeleteHandler(ctx, agentName, int64(handlerID)); err != nil {
|
||||
return mcp.NewToolResultError(fmt.Sprintf("delete_k8s_handler failed: %s", err)), nil
|
||||
}
|
||||
|
||||
return resultJSON(map[string]any{
|
||||
"deleted": true,
|
||||
"handler_id": handlerID,
|
||||
})
|
||||
}
|
||||
|
||||
// parseEvents splits a comma-separated event string into a trimmed slice.
|
||||
func parseEvents(s string) []string {
|
||||
parts := strings.Split(s, ",")
|
||||
events := make([]string, 0, len(parts))
|
||||
for _, p := range parts {
|
||||
p = strings.TrimSpace(p)
|
||||
if p != "" {
|
||||
events = append(events, p)
|
||||
}
|
||||
}
|
||||
return events
|
||||
}
|
||||
@@ -17,15 +17,26 @@ type ReadOptions struct {
|
||||
ConversationID *int64 `json:"conversation_id,omitempty"`
|
||||
MinPriority int `json:"min_priority,omitempty"`
|
||||
Limit int `json:"limit,omitempty"`
|
||||
Offset int `json:"offset,omitempty"`
|
||||
After string `json:"after,omitempty"`
|
||||
Before string `json:"before,omitempty"`
|
||||
IncludeRead bool `json:"include_read,omitempty"`
|
||||
}
|
||||
|
||||
// SearchOptions configures message search behavior.
|
||||
type SearchOptions struct {
|
||||
FromAgent string `json:"from_agent,omitempty"`
|
||||
ToAgent string `json:"to_agent,omitempty"`
|
||||
ChannelID *int64 `json:"channel_id,omitempty"`
|
||||
MinPriority int `json:"min_priority,omitempty"`
|
||||
Status string `json:"status,omitempty"`
|
||||
Limit int `json:"limit,omitempty"`
|
||||
FromAgent string `json:"from_agent,omitempty"`
|
||||
ToAgent string `json:"to_agent,omitempty"`
|
||||
ChannelID *int64 `json:"channel_id,omitempty"`
|
||||
MinPriority int `json:"min_priority,omitempty"`
|
||||
Status string `json:"status,omitempty"`
|
||||
Limit int `json:"limit,omitempty"`
|
||||
Offset int `json:"offset,omitempty"`
|
||||
After string `json:"after,omitempty"`
|
||||
Before string `json:"before,omitempty"`
|
||||
Channel string `json:"channel,omitempty"`
|
||||
Channels []string `json:"channels,omitempty"` // include messages in these channels
|
||||
ExcludeChannels []string `json:"exclude_channels,omitempty"` // exclude messages in these channels
|
||||
Agents []string `json:"agents,omitempty"` // include messages from/to these agents
|
||||
ExcludeAgents []string `json:"exclude_agents,omitempty"` // exclude messages from/to these agents
|
||||
}
|
||||
|
||||
@@ -12,11 +12,25 @@ import (
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
// EmbeddingNotifier is called when messages are created or deleted so the
|
||||
// embedding pipeline can enqueue them without a direct import dependency.
|
||||
type EmbeddingNotifier interface {
|
||||
OnMessageCreated(ctx context.Context, messageID int64, body string)
|
||||
}
|
||||
|
||||
// MessageListener is notified after every message is persisted.
|
||||
// Implementations must not block — use goroutines for slow work.
|
||||
type MessageListener interface {
|
||||
OnMessageSent(ctx context.Context, msg *Message)
|
||||
}
|
||||
|
||||
// MessagingService provides business logic for messaging operations.
|
||||
type MessagingService struct {
|
||||
store MessageStore
|
||||
tracer *trace.Tracer
|
||||
dispatcher dispatcher.EventDispatcher
|
||||
embeddings EmbeddingNotifier
|
||||
listeners []MessageListener
|
||||
logger *slog.Logger
|
||||
}
|
||||
|
||||
@@ -34,6 +48,16 @@ func (s *MessagingService) SetDispatcher(d dispatcher.EventDispatcher) {
|
||||
s.dispatcher = d
|
||||
}
|
||||
|
||||
// SetEmbeddingNotifier sets the embedding pipeline callback for new messages.
|
||||
func (s *MessagingService) SetEmbeddingNotifier(n EmbeddingNotifier) {
|
||||
s.embeddings = n
|
||||
}
|
||||
|
||||
// AddMessageListener registers a listener that is notified after message creation.
|
||||
func (s *MessagingService) AddMessageListener(l MessageListener) {
|
||||
s.listeners = append(s.listeners, l)
|
||||
}
|
||||
|
||||
// SendMessage creates a message, auto-creating conversations as needed.
|
||||
func (s *MessagingService) SendMessage(ctx context.Context, from, to, body string, opts SendOptions) (*Message, error) {
|
||||
// Validate inputs
|
||||
@@ -121,6 +145,16 @@ func (s *MessagingService) SendMessage(ctx context.Context, from, to, body strin
|
||||
return nil, fmt.Errorf("insert message: %w", err)
|
||||
}
|
||||
|
||||
// Enqueue for embedding (async, best-effort)
|
||||
if s.embeddings != nil {
|
||||
s.embeddings.OnMessageCreated(ctx, msg.ID, msg.Body)
|
||||
}
|
||||
|
||||
// Notify listeners (SSE, etc.)
|
||||
for _, l := range s.listeners {
|
||||
l.OnMessageSent(ctx, msg)
|
||||
}
|
||||
|
||||
s.logger.Info("message sent",
|
||||
"from", from,
|
||||
"to", to,
|
||||
@@ -176,12 +210,22 @@ func (s *MessagingService) SendMessage(ctx context.Context, from, to, body strin
|
||||
}
|
||||
|
||||
// ReadInbox returns messages for an agent and advances the read position.
|
||||
func (s *MessagingService) ReadInbox(ctx context.Context, agentName string, opts ReadOptions) ([]*Message, error) {
|
||||
func (s *MessagingService) ReadInbox(ctx context.Context, agentName string, opts ReadOptions) (*PaginatedMessages, error) {
|
||||
messages, err := s.store.GetInboxMessages(ctx, agentName, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get inbox messages: %w", err)
|
||||
}
|
||||
|
||||
total, err := s.store.CountInboxMessages(ctx, agentName, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("count inbox messages: %w", err)
|
||||
}
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
|
||||
// Advance inbox state for each conversation
|
||||
conversationMaxID := make(map[int64]int64)
|
||||
for _, msg := range messages {
|
||||
@@ -212,7 +256,12 @@ func (s *MessagingService) ReadInbox(ctx context.Context, agentName string, opts
|
||||
})
|
||||
}
|
||||
|
||||
return messages, nil
|
||||
return &PaginatedMessages{
|
||||
Messages: messages,
|
||||
Total: total,
|
||||
Offset: opts.Offset,
|
||||
Limit: limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// ClaimMessages atomically claims pending messages for processing.
|
||||
@@ -333,12 +382,22 @@ func (s *MessagingService) MarkFailed(ctx context.Context, messageID int64, agen
|
||||
}
|
||||
|
||||
// SearchMessages performs full-text search on messages.
|
||||
func (s *MessagingService) SearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) ([]*Message, error) {
|
||||
func (s *MessagingService) SearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) (*PaginatedMessages, error) {
|
||||
messages, err := s.store.SearchMessages(ctx, agentName, query, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("search messages: %w", err)
|
||||
}
|
||||
|
||||
total, err := s.store.CountSearchMessages(ctx, agentName, query, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("count search messages: %w", err)
|
||||
}
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 20
|
||||
}
|
||||
|
||||
s.logger.Info("messages searched",
|
||||
"agent", agentName,
|
||||
"query", query,
|
||||
@@ -352,7 +411,12 @@ func (s *MessagingService) SearchMessages(ctx context.Context, agentName, query
|
||||
})
|
||||
}
|
||||
|
||||
return messages, nil
|
||||
return &PaginatedMessages{
|
||||
Messages: messages,
|
||||
Total: total,
|
||||
Offset: opts.Offset,
|
||||
Limit: limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetPendingDMCount returns the total count of pending DMs for an agent.
|
||||
@@ -397,12 +461,27 @@ func (s *MessagingService) GetReplies(ctx context.Context, messageID int64) ([]*
|
||||
}
|
||||
|
||||
// GetChannelMessages returns messages posted to a channel.
|
||||
func (s *MessagingService) GetChannelMessages(ctx context.Context, channelID int64, limit int) ([]*Message, error) {
|
||||
messages, err := s.store.GetChannelMessages(ctx, channelID, limit)
|
||||
func (s *MessagingService) GetChannelMessages(ctx context.Context, channelID int64, limit, offset int) (*PaginatedMessages, error) {
|
||||
messages, err := s.store.GetChannelMessages(ctx, channelID, limit, offset)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get channel messages: %w", err)
|
||||
}
|
||||
return messages, nil
|
||||
|
||||
total, err := s.store.CountChannelMessages(ctx, channelID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("count channel messages: %w", err)
|
||||
}
|
||||
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
|
||||
return &PaginatedMessages{
|
||||
Messages: messages,
|
||||
Total: total,
|
||||
Offset: offset,
|
||||
Limit: limit,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetDMMessages returns direct messages between owned agents and a peer agent.
|
||||
@@ -414,6 +493,36 @@ func (s *MessagingService) GetDMMessages(ctx context.Context, ownedAgents []stri
|
||||
return messages, nil
|
||||
}
|
||||
|
||||
// GetDMUnreadCounts returns unread DM counts grouped by peer agent.
|
||||
func (s *MessagingService) GetDMUnreadCounts(ctx context.Context, agentName string) ([]DMUnreadCount, error) {
|
||||
return s.store.GetDMUnreadCounts(ctx, agentName)
|
||||
}
|
||||
|
||||
// GetLastReadForChannel returns the last_read_message_id for an agent in a channel.
|
||||
func (s *MessagingService) GetLastReadForChannel(ctx context.Context, agentName string, channelID int64) (int64, error) {
|
||||
return s.store.GetLastReadForChannel(ctx, agentName, channelID)
|
||||
}
|
||||
|
||||
// GetLastReadForDM returns the last_read_message_id for owned agents in a DM with a peer.
|
||||
func (s *MessagingService) GetLastReadForDM(ctx context.Context, agentNames []string, peerAgent string) (int64, error) {
|
||||
return s.store.GetLastReadForDM(ctx, agentNames, peerAgent)
|
||||
}
|
||||
|
||||
// UpdateInboxState updates the read position for an agent in a conversation.
|
||||
func (s *MessagingService) UpdateInboxState(ctx context.Context, agentName string, conversationID int64, lastReadMsgID int64) error {
|
||||
return s.store.UpdateInboxState(ctx, agentName, conversationID, lastReadMsgID)
|
||||
}
|
||||
|
||||
// GetConversationIDsForChannel returns conversation IDs in a channel with messages up to lastMessageID.
|
||||
func (s *MessagingService) GetConversationIDsForChannel(ctx context.Context, channelID int64, lastMessageID int64) ([]int64, error) {
|
||||
return s.store.GetConversationIDsForChannel(ctx, channelID, lastMessageID)
|
||||
}
|
||||
|
||||
// GetConversationIDsForDM returns conversation IDs for DMs between owned agents and a peer.
|
||||
func (s *MessagingService) GetConversationIDsForDM(ctx context.Context, agentNames []string, peerAgent string, lastMessageID int64) ([]int64, error) {
|
||||
return s.store.GetConversationIDsForDM(ctx, agentNames, peerAgent, lastMessageID)
|
||||
}
|
||||
|
||||
// GetConversation returns a conversation and its messages.
|
||||
func (s *MessagingService) GetConversation(ctx context.Context, id int64) (*Conversation, []*Message, error) {
|
||||
conv, err := s.store.GetConversation(ctx, id)
|
||||
|
||||
@@ -193,15 +193,18 @@ func TestMessagingService_ReadInbox(t *testing.T) {
|
||||
}
|
||||
|
||||
t.Run("returns messages ordered by priority desc", func(t *testing.T) {
|
||||
messages, err := svc.ReadInbox(ctx, "receiver", ReadOptions{IncludeRead: true})
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{IncludeRead: true})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Fatalf("got %d messages, want 2", len(messages))
|
||||
if len(result.Messages) != 2 {
|
||||
t.Fatalf("got %d messages, want 2", len(result.Messages))
|
||||
}
|
||||
if messages[0].Priority < messages[1].Priority {
|
||||
t.Errorf("messages not ordered by priority desc: %d, %d", messages[0].Priority, messages[1].Priority)
|
||||
if result.Messages[0].Priority < result.Messages[1].Priority {
|
||||
t.Errorf("messages not ordered by priority desc: %d, %d", result.Messages[0].Priority, result.Messages[1].Priority)
|
||||
}
|
||||
if result.Total != 2 {
|
||||
t.Errorf("total = %d, want 2", result.Total)
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -220,30 +223,30 @@ func TestMessagingService_ReadInbox_ReadUnread(t *testing.T) {
|
||||
}
|
||||
|
||||
// First read
|
||||
messages, err := svc.ReadInbox(ctx, "receiver", ReadOptions{})
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) == 0 {
|
||||
if len(result.Messages) == 0 {
|
||||
t.Fatal("expected messages on first read")
|
||||
}
|
||||
|
||||
// Second read without include_read
|
||||
messages, err = svc.ReadInbox(ctx, "receiver", ReadOptions{})
|
||||
result, err = svc.ReadInbox(ctx, "receiver", ReadOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 0 {
|
||||
t.Errorf("got %d messages on second read (no include_read), want 0", len(messages))
|
||||
if len(result.Messages) != 0 {
|
||||
t.Errorf("got %d messages on second read (no include_read), want 0", len(result.Messages))
|
||||
}
|
||||
|
||||
// With include_read
|
||||
messages, err = svc.ReadInbox(ctx, "receiver", ReadOptions{IncludeRead: true})
|
||||
result, err = svc.ReadInbox(ctx, "receiver", ReadOptions{IncludeRead: true})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Errorf("got %d messages with include_read, want 2", len(messages))
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages with include_read, want 2", len(result.Messages))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -255,52 +258,52 @@ func TestMessagingService_ReadInbox_Filters(t *testing.T) {
|
||||
svc.SendMessage(ctx, "sender", "receiver", "high pri", SendOptions{Priority: 8})
|
||||
|
||||
t.Run("filter by from_agent", func(t *testing.T) {
|
||||
messages, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
FromAgent: "sender",
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Errorf("got %d messages from sender, want 2", len(messages))
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages from sender, want 2", len(result.Messages))
|
||||
}
|
||||
|
||||
messages, err = svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
result, err = svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
FromAgent: "nobody",
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 0 {
|
||||
t.Errorf("got %d messages from nobody, want 0", len(messages))
|
||||
if len(result.Messages) != 0 {
|
||||
t.Errorf("got %d messages from nobody, want 0", len(result.Messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by min_priority", func(t *testing.T) {
|
||||
messages, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
MinPriority: 7,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 1 {
|
||||
t.Errorf("got %d messages with min_priority=7, want 1", len(messages))
|
||||
if len(result.Messages) != 1 {
|
||||
t.Errorf("got %d messages with min_priority=7, want 1", len(result.Messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("limit", func(t *testing.T) {
|
||||
messages, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
Limit: 1,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(messages) != 1 {
|
||||
t.Errorf("got %d messages with limit=1, want 1", len(messages))
|
||||
if len(result.Messages) != 1 {
|
||||
t.Errorf("got %d messages with limit=1, want 1", len(result.Messages))
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -457,22 +460,25 @@ func TestMessagingService_SearchMessages(t *testing.T) {
|
||||
svc.SendMessage(ctx, "sender", "receiver", "security alert detected", SendOptions{Priority: 9})
|
||||
|
||||
t.Run("keyword search", func(t *testing.T) {
|
||||
results, err := svc.SearchMessages(ctx, "receiver", "deployment", SearchOptions{})
|
||||
result, err := svc.SearchMessages(ctx, "receiver", "deployment", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(results))
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 2 {
|
||||
t.Errorf("total = %d, want 2", result.Total)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty query returns recent", func(t *testing.T) {
|
||||
results, err := svc.SearchMessages(ctx, "receiver", "", SearchOptions{})
|
||||
result, err := svc.SearchMessages(ctx, "receiver", "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 3 {
|
||||
t.Errorf("got %d results, want 3", len(results))
|
||||
if len(result.Messages) != 3 {
|
||||
t.Errorf("got %d results, want 3", len(result.Messages))
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -522,5 +528,205 @@ func TestMessagingService_TracesRecorded(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessagingService_ReadInbox_Pagination(t *testing.T) {
|
||||
svc, _ := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Send 5 messages
|
||||
for i := 0; i < 5; i++ {
|
||||
_, err := svc.SendMessage(ctx, "sender", "receiver", "paginated msg", SendOptions{Priority: 5})
|
||||
if err != nil {
|
||||
t.Fatalf("SendMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("offset pagination returns correct page", func(t *testing.T) {
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
Limit: 2,
|
||||
Offset: 0,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
if result.Offset != 0 {
|
||||
t.Errorf("offset = %d, want 0", result.Offset)
|
||||
}
|
||||
if result.Limit != 2 {
|
||||
t.Errorf("limit = %d, want 2", result.Limit)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset=3 returns remaining 2", func(t *testing.T) {
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
Limit: 10,
|
||||
Offset: 3,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset beyond total returns empty", func(t *testing.T) {
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
Limit: 10,
|
||||
Offset: 100,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 0 {
|
||||
t.Errorf("got %d messages, want 0", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestMessagingService_SearchMessages_Pagination(t *testing.T) {
|
||||
svc, _ := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
svc.SendMessage(ctx, "sender", "receiver", "searchable item", SendOptions{Priority: 5})
|
||||
}
|
||||
|
||||
t.Run("pagination with total count", func(t *testing.T) {
|
||||
result, err := svc.SearchMessages(ctx, "receiver", "searchable", SearchOptions{
|
||||
Limit: 2,
|
||||
Offset: 0,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
if result.Offset != 0 {
|
||||
t.Errorf("offset = %d, want 0", result.Offset)
|
||||
}
|
||||
if result.Limit != 2 {
|
||||
t.Errorf("limit = %d, want 2", result.Limit)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("second page", func(t *testing.T) {
|
||||
result, err := svc.SearchMessages(ctx, "receiver", "searchable", SearchOptions{
|
||||
Limit: 2,
|
||||
Offset: 2,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestMessagingService_GetChannelMessages_Pagination(t *testing.T) {
|
||||
svc, db := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Create a channel
|
||||
_, err := db.Exec(
|
||||
`INSERT INTO channels (id, name, description, topic, type, is_private, is_system, created_by, created_at, updated_at)
|
||||
VALUES (1, 'pag-channel', '', '', 'standard', 0, 0, 'sender', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("create channel: %v", err)
|
||||
}
|
||||
|
||||
chID := int64(1)
|
||||
for i := 0; i < 5; i++ {
|
||||
svc.SendMessage(ctx, "sender", "", "ch msg", SendOptions{
|
||||
ChannelID: &chID,
|
||||
Priority: 5,
|
||||
})
|
||||
}
|
||||
|
||||
t.Run("pagination with total", func(t *testing.T) {
|
||||
result, err := svc.GetChannelMessages(ctx, 1, 2, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("GetChannelMessages: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
if result.Offset != 0 {
|
||||
t.Errorf("offset = %d, want 0", result.Offset)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset=3 returns remaining", func(t *testing.T) {
|
||||
result, err := svc.GetChannelMessages(ctx, 1, 10, 3)
|
||||
if err != nil {
|
||||
t.Fatalf("GetChannelMessages: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(result.Messages))
|
||||
}
|
||||
if result.Total != 5 {
|
||||
t.Errorf("total = %d, want 5", result.Total)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestMessagingService_ReadInbox_DateFiltering(t *testing.T) {
|
||||
svc, _ := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
svc.SendMessage(ctx, "sender", "receiver", "dated msg", SendOptions{Priority: 5})
|
||||
|
||||
t.Run("after in the past returns messages", func(t *testing.T) {
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
IncludeRead: true,
|
||||
After: "2020-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 1 {
|
||||
t.Errorf("got %d messages, want 1", len(result.Messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("after in the future returns empty", func(t *testing.T) {
|
||||
result, err := svc.ReadInbox(ctx, "receiver", ReadOptions{
|
||||
IncludeRead: true,
|
||||
After: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ReadInbox: %v", err)
|
||||
}
|
||||
if len(result.Messages) != 0 {
|
||||
t.Errorf("got %d messages, want 0", len(result.Messages))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// suppress unused import warning for storage package
|
||||
var _ = storage.RunMigrations
|
||||
|
||||
@@ -0,0 +1,471 @@
|
||||
package messaging
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// StalemateConfig holds stalemate detection settings.
|
||||
type StalemateConfig struct {
|
||||
// ProcessingTimeout is how long a message can stay in "processing" before auto-fail (default 24h).
|
||||
ProcessingTimeout time.Duration
|
||||
// ReminderAfter is how long a pending DM waits before a system reminder is sent (default 4h).
|
||||
ReminderAfter time.Duration
|
||||
// EscalateAfter is how long a pending DM waits before escalation to #approvals (default 48h).
|
||||
EscalateAfter time.Duration
|
||||
// Interval is how often the worker checks for stale messages (default 15m).
|
||||
Interval time.Duration
|
||||
}
|
||||
|
||||
// DefaultStalemateConfig returns the default stalemate configuration.
|
||||
func DefaultStalemateConfig() StalemateConfig {
|
||||
return StalemateConfig{
|
||||
ProcessingTimeout: 24 * time.Hour,
|
||||
ReminderAfter: 4 * time.Hour,
|
||||
EscalateAfter: 48 * time.Hour,
|
||||
Interval: 15 * time.Minute,
|
||||
}
|
||||
}
|
||||
|
||||
// parseDurationWithDays parses a duration string supporting "Nd" format for days
|
||||
// in addition to standard Go duration formats.
|
||||
func parseDurationWithDays(s string) (time.Duration, error) {
|
||||
s = strings.TrimSpace(s)
|
||||
if s == "" {
|
||||
return 0, fmt.Errorf("empty duration string")
|
||||
}
|
||||
|
||||
// Try "Nd" format (days)
|
||||
if strings.HasSuffix(s, "d") {
|
||||
days, err := strconv.Atoi(strings.TrimSuffix(s, "d"))
|
||||
if err == nil && days > 0 {
|
||||
return time.Duration(days) * 24 * time.Hour, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Try standard Go duration
|
||||
return time.ParseDuration(s)
|
||||
}
|
||||
|
||||
// ParseStalemateConfig reads stalemate configuration from environment variables.
|
||||
func ParseStalemateConfig() StalemateConfig {
|
||||
cfg := DefaultStalemateConfig()
|
||||
|
||||
if v := os.Getenv("SYNAPBUS_STALEMATE_PROCESSING_TIMEOUT"); v != "" {
|
||||
if d, err := parseDurationWithDays(v); err == nil && d > 0 {
|
||||
cfg.ProcessingTimeout = d
|
||||
}
|
||||
}
|
||||
if v := os.Getenv("SYNAPBUS_STALEMATE_REMINDER_AFTER"); v != "" {
|
||||
if d, err := parseDurationWithDays(v); err == nil && d > 0 {
|
||||
cfg.ReminderAfter = d
|
||||
}
|
||||
}
|
||||
if v := os.Getenv("SYNAPBUS_STALEMATE_ESCALATE_AFTER"); v != "" {
|
||||
if d, err := parseDurationWithDays(v); err == nil && d > 0 {
|
||||
cfg.EscalateAfter = d
|
||||
}
|
||||
}
|
||||
if v := os.Getenv("SYNAPBUS_STALEMATE_INTERVAL"); v != "" {
|
||||
if d, err := parseDurationWithDays(v); err == nil && d > 0 {
|
||||
cfg.Interval = d
|
||||
}
|
||||
}
|
||||
|
||||
return cfg
|
||||
}
|
||||
|
||||
// ChannelLookup provides channel lookup by name without importing the channels package.
|
||||
type ChannelLookup interface {
|
||||
// GetChannelIDByName returns a channel ID by name, or 0 if not found.
|
||||
GetChannelIDByName(ctx context.Context, name string) (int64, error)
|
||||
}
|
||||
|
||||
// StalemateWorker periodically checks for and handles stale messages.
|
||||
type StalemateWorker struct {
|
||||
db *sql.DB
|
||||
msgService *MessagingService
|
||||
channelLookup ChannelLookup
|
||||
config StalemateConfig
|
||||
logger *slog.Logger
|
||||
done chan struct{}
|
||||
wg sync.WaitGroup
|
||||
}
|
||||
|
||||
// NewStalemateWorker creates a new stalemate detection worker.
|
||||
func NewStalemateWorker(db *sql.DB, msgService *MessagingService, channelLookup ChannelLookup, config StalemateConfig) *StalemateWorker {
|
||||
return &StalemateWorker{
|
||||
db: db,
|
||||
msgService: msgService,
|
||||
channelLookup: channelLookup,
|
||||
config: config,
|
||||
logger: slog.Default().With("component", "stalemate-worker"),
|
||||
done: make(chan struct{}),
|
||||
}
|
||||
}
|
||||
|
||||
// Start begins the background stalemate check loop.
|
||||
func (w *StalemateWorker) Start() {
|
||||
w.wg.Add(1)
|
||||
go func() {
|
||||
defer w.wg.Done()
|
||||
w.logger.Info("stalemate worker started",
|
||||
"interval", w.config.Interval.String(),
|
||||
"processing_timeout", w.config.ProcessingTimeout.String(),
|
||||
"reminder_after", w.config.ReminderAfter.String(),
|
||||
"escalate_after", w.config.EscalateAfter.String(),
|
||||
)
|
||||
|
||||
ticker := time.NewTicker(w.config.Interval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
||||
w.checkStaleMessages(ctx)
|
||||
cancel()
|
||||
case <-w.done:
|
||||
w.logger.Info("stalemate worker stopped")
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// Stop stops the stalemate worker and waits for it to finish.
|
||||
func (w *StalemateWorker) Stop() {
|
||||
close(w.done)
|
||||
w.wg.Wait()
|
||||
}
|
||||
|
||||
// checkStaleMessages runs all stalemate checks.
|
||||
func (w *StalemateWorker) checkStaleMessages(ctx context.Context) {
|
||||
failed := w.failTimedOutProcessing(ctx)
|
||||
reminded := w.sendPendingReminders(ctx)
|
||||
escalated := w.escalatePendingMessages(ctx)
|
||||
|
||||
if failed > 0 || reminded > 0 || escalated > 0 {
|
||||
w.logger.Info("stalemate check complete",
|
||||
"auto_failed", failed,
|
||||
"reminders_sent", reminded,
|
||||
"escalations_sent", escalated,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// staleDM represents a stale direct message found by the worker.
|
||||
type staleDM struct {
|
||||
ID int64
|
||||
FromAgent string
|
||||
ToAgent string
|
||||
Body string
|
||||
ClaimedAt *time.Time
|
||||
ClaimedBy string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// failTimedOutProcessing auto-fails DMs in "processing" status that have exceeded the timeout.
|
||||
func (w *StalemateWorker) failTimedOutProcessing(ctx context.Context) int64 {
|
||||
cutoff := time.Now().Add(-w.config.ProcessingTimeout)
|
||||
|
||||
rows, err := w.db.QueryContext(ctx,
|
||||
`SELECT id, from_agent, to_agent, body, claimed_at, claimed_by
|
||||
FROM messages
|
||||
WHERE status = 'processing'
|
||||
AND to_agent IS NOT NULL
|
||||
AND to_agent != ''
|
||||
AND to_agent != 'system'
|
||||
AND claimed_at < ?`,
|
||||
cutoff,
|
||||
)
|
||||
if err != nil {
|
||||
w.logger.Error("query timed-out processing messages failed", "error", err)
|
||||
return 0
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var stale []staleDM
|
||||
for rows.Next() {
|
||||
var dm staleDM
|
||||
var claimedAt sql.NullTime
|
||||
var claimedBy sql.NullString
|
||||
if err := rows.Scan(&dm.ID, &dm.FromAgent, &dm.ToAgent, &dm.Body, &claimedAt, &claimedBy); err != nil {
|
||||
w.logger.Error("scan timed-out message failed", "error", err)
|
||||
continue
|
||||
}
|
||||
if claimedAt.Valid {
|
||||
dm.ClaimedAt = &claimedAt.Time
|
||||
}
|
||||
if claimedBy.Valid {
|
||||
dm.ClaimedBy = claimedBy.String
|
||||
}
|
||||
stale = append(stale, dm)
|
||||
}
|
||||
|
||||
count := int64(0)
|
||||
for _, dm := range stale {
|
||||
metadata := map[string]any{"error": "claim timeout exceeded"}
|
||||
metaBytes, _ := json.Marshal(metadata)
|
||||
|
||||
// Update directly via DB since the store's UpdateMessageStatus requires the claiming agent
|
||||
_, err := w.db.ExecContext(ctx,
|
||||
`UPDATE messages SET status = ?, metadata = ?, updated_at = CURRENT_TIMESTAMP
|
||||
WHERE id = ? AND status = 'processing'`,
|
||||
StatusFailed, string(metaBytes), dm.ID,
|
||||
)
|
||||
if err != nil {
|
||||
w.logger.Error("auto-fail message failed",
|
||||
"message_id", dm.ID,
|
||||
"error", err,
|
||||
)
|
||||
continue
|
||||
}
|
||||
w.logger.Info("auto-failed stale processing message",
|
||||
"message_id", dm.ID,
|
||||
"from_agent", dm.FromAgent,
|
||||
"to_agent", dm.ToAgent,
|
||||
"claimed_by", dm.ClaimedBy,
|
||||
)
|
||||
count++
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// sendPendingReminders sends system DM reminders for pending messages older than ReminderAfter.
|
||||
func (w *StalemateWorker) sendPendingReminders(ctx context.Context) int64 {
|
||||
cutoff := time.Now().Add(-w.config.ReminderAfter)
|
||||
|
||||
rows, err := w.db.QueryContext(ctx,
|
||||
`SELECT id, from_agent, to_agent, body, created_at
|
||||
FROM messages
|
||||
WHERE status = 'pending'
|
||||
AND to_agent IS NOT NULL
|
||||
AND to_agent != ''
|
||||
AND from_agent != 'system'
|
||||
AND to_agent != 'system'
|
||||
AND created_at < ?`,
|
||||
cutoff,
|
||||
)
|
||||
if err != nil {
|
||||
w.logger.Error("query pending reminder candidates failed", "error", err)
|
||||
return 0
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type pendingMsg struct {
|
||||
ID int64
|
||||
FromAgent string
|
||||
ToAgent string
|
||||
Body string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
var pending []pendingMsg
|
||||
for rows.Next() {
|
||||
var pm pendingMsg
|
||||
if err := rows.Scan(&pm.ID, &pm.FromAgent, &pm.ToAgent, &pm.Body, &pm.CreatedAt); err != nil {
|
||||
w.logger.Error("scan pending message failed", "error", err)
|
||||
continue
|
||||
}
|
||||
pending = append(pending, pm)
|
||||
}
|
||||
|
||||
count := int64(0)
|
||||
for _, pm := range pending {
|
||||
// Check if a reminder already exists for this message
|
||||
if w.reminderExists(ctx, pm.ID, pm.ToAgent) {
|
||||
continue
|
||||
}
|
||||
|
||||
age := formatAge(time.Since(pm.CreatedAt))
|
||||
truncBody := truncate(pm.Body, 100)
|
||||
|
||||
body := fmt.Sprintf(
|
||||
"**Reminder**: You have a pending message from %s (%s old). Message: \"%s\". Please claim and process it.",
|
||||
pm.FromAgent, age, truncBody,
|
||||
)
|
||||
|
||||
_, err := w.msgService.SendMessage(ctx, "system", pm.ToAgent, body, SendOptions{
|
||||
Subject: fmt.Sprintf("stalemate-reminder:%d", pm.ID),
|
||||
Priority: 7,
|
||||
Metadata: fmt.Sprintf(`{"stalemate_reminder_for":%d}`, pm.ID),
|
||||
})
|
||||
if err != nil {
|
||||
w.logger.Error("send stalemate reminder failed",
|
||||
"message_id", pm.ID,
|
||||
"to_agent", pm.ToAgent,
|
||||
"error", err,
|
||||
)
|
||||
continue
|
||||
}
|
||||
w.logger.Info("sent stalemate reminder",
|
||||
"message_id", pm.ID,
|
||||
"to_agent", pm.ToAgent,
|
||||
"from_agent", pm.FromAgent,
|
||||
"age", age,
|
||||
)
|
||||
count++
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// escalatePendingMessages escalates pending messages older than EscalateAfter to #approvals.
|
||||
func (w *StalemateWorker) escalatePendingMessages(ctx context.Context) int64 {
|
||||
cutoff := time.Now().Add(-w.config.EscalateAfter)
|
||||
|
||||
rows, err := w.db.QueryContext(ctx,
|
||||
`SELECT id, from_agent, to_agent, body, created_at
|
||||
FROM messages
|
||||
WHERE status = 'pending'
|
||||
AND to_agent IS NOT NULL
|
||||
AND to_agent != ''
|
||||
AND from_agent != 'system'
|
||||
AND to_agent != 'system'
|
||||
AND created_at < ?`,
|
||||
cutoff,
|
||||
)
|
||||
if err != nil {
|
||||
w.logger.Error("query escalation candidates failed", "error", err)
|
||||
return 0
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type pendingMsg struct {
|
||||
ID int64
|
||||
FromAgent string
|
||||
ToAgent string
|
||||
Body string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
var pending []pendingMsg
|
||||
for rows.Next() {
|
||||
var pm pendingMsg
|
||||
if err := rows.Scan(&pm.ID, &pm.FromAgent, &pm.ToAgent, &pm.Body, &pm.CreatedAt); err != nil {
|
||||
w.logger.Error("scan escalation candidate failed", "error", err)
|
||||
continue
|
||||
}
|
||||
pending = append(pending, pm)
|
||||
}
|
||||
|
||||
if len(pending) == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
// Look up #approvals channel
|
||||
channelID, err := w.channelLookup.GetChannelIDByName(ctx, "approvals")
|
||||
if err != nil {
|
||||
w.logger.Warn("cannot escalate: #approvals channel not found", "error", err)
|
||||
return 0
|
||||
}
|
||||
|
||||
count := int64(0)
|
||||
for _, pm := range pending {
|
||||
// Check if already escalated
|
||||
if w.escalationExists(ctx, pm.ID) {
|
||||
continue
|
||||
}
|
||||
|
||||
age := formatAge(time.Since(pm.CreatedAt))
|
||||
truncBody := truncate(pm.Body, 100)
|
||||
|
||||
body := fmt.Sprintf(
|
||||
"**ESCALATION**: Pending message for @%s from %s has been unprocessed for %s. Message: \"%s\". Manual intervention may be required.",
|
||||
pm.ToAgent, pm.FromAgent, age, truncBody,
|
||||
)
|
||||
|
||||
_, err := w.msgService.SendMessage(ctx, "system", "", body, SendOptions{
|
||||
Subject: fmt.Sprintf("stalemate-escalation:%d", pm.ID),
|
||||
Priority: 9,
|
||||
Metadata: fmt.Sprintf(`{"stalemate_escalation_for":%d}`, pm.ID),
|
||||
ChannelID: &channelID,
|
||||
})
|
||||
if err != nil {
|
||||
w.logger.Error("send escalation to #approvals failed",
|
||||
"message_id", pm.ID,
|
||||
"error", err,
|
||||
)
|
||||
continue
|
||||
}
|
||||
w.logger.Info("escalated stale message to #approvals",
|
||||
"message_id", pm.ID,
|
||||
"to_agent", pm.ToAgent,
|
||||
"from_agent", pm.FromAgent,
|
||||
"age", age,
|
||||
)
|
||||
count++
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// reminderExists checks if a system reminder already exists for a given message ID.
|
||||
func (w *StalemateWorker) reminderExists(ctx context.Context, messageID int64, toAgent string) bool {
|
||||
var count int
|
||||
err := w.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages
|
||||
WHERE from_agent = 'system'
|
||||
AND to_agent = ?
|
||||
AND metadata LIKE ?`,
|
||||
toAgent, fmt.Sprintf(`%%"stalemate_reminder_for":%d%%`, messageID),
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return count > 0
|
||||
}
|
||||
|
||||
// escalationExists checks if an escalation already exists for a given message ID.
|
||||
func (w *StalemateWorker) escalationExists(ctx context.Context, messageID int64) bool {
|
||||
var count int
|
||||
err := w.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages
|
||||
WHERE from_agent = 'system'
|
||||
AND metadata LIKE ?`,
|
||||
fmt.Sprintf(`%%"stalemate_escalation_for":%d%%`, messageID),
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return count > 0
|
||||
}
|
||||
|
||||
// truncate truncates a string to maxLen characters, appending "..." if truncated.
|
||||
func truncate(s string, maxLen int) string {
|
||||
runes := []rune(s)
|
||||
if len(runes) <= maxLen {
|
||||
return s
|
||||
}
|
||||
return string(runes[:maxLen]) + "..."
|
||||
}
|
||||
|
||||
// formatAge returns a human-readable age string.
|
||||
func formatAge(d time.Duration) string {
|
||||
if d < time.Hour {
|
||||
return fmt.Sprintf("%dm", int(d.Minutes()))
|
||||
}
|
||||
hours := int(d.Hours())
|
||||
if hours < 24 {
|
||||
return fmt.Sprintf("%dh", hours)
|
||||
}
|
||||
days := hours / 24
|
||||
remainingHours := hours % 24
|
||||
if remainingHours == 0 {
|
||||
if days == 1 {
|
||||
return "1 day"
|
||||
}
|
||||
return fmt.Sprintf("%d days", days)
|
||||
}
|
||||
if days == 1 {
|
||||
return fmt.Sprintf("1 day %dh", remainingHours)
|
||||
}
|
||||
return fmt.Sprintf("%d days %dh", days, remainingHours)
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
package messaging
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/trace"
|
||||
)
|
||||
|
||||
// stubChannelLookup implements ChannelLookup for tests.
|
||||
type stubChannelLookup struct {
|
||||
channelID int64
|
||||
err error
|
||||
}
|
||||
|
||||
func (s *stubChannelLookup) GetChannelIDByName(ctx context.Context, name string) (int64, error) {
|
||||
if s.err != nil {
|
||||
return 0, s.err
|
||||
}
|
||||
return s.channelID, nil
|
||||
}
|
||||
|
||||
// newStalemateTestService creates a MessagingService and DB for stalemate tests.
|
||||
func newStalemateTestService(t *testing.T) (*MessagingService, *sql.DB) {
|
||||
t.Helper()
|
||||
db := newTestDB(t)
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "receiver")
|
||||
seedAgent(t, db, "system")
|
||||
|
||||
store := NewSQLiteMessageStore(db)
|
||||
tracer := trace.NewTracer(db)
|
||||
t.Cleanup(func() { tracer.Close() })
|
||||
|
||||
svc := NewMessagingService(store, tracer)
|
||||
return svc, db
|
||||
}
|
||||
|
||||
// insertStaleMessage inserts a message with a specific created_at and claimed_at for testing.
|
||||
func insertStaleMessage(t *testing.T, db *sql.DB, from, to, body, status string, createdAt time.Time, claimedAt *time.Time, claimedBy string) int64 {
|
||||
t.Helper()
|
||||
|
||||
// Insert conversation first
|
||||
result, err := db.Exec(
|
||||
`INSERT INTO conversations (subject, created_by, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?)`,
|
||||
"stalemate-test", from, createdAt, createdAt,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("insert conversation: %v", err)
|
||||
}
|
||||
convID, _ := result.LastInsertId()
|
||||
|
||||
var claimedAtSQL interface{} = nil
|
||||
if claimedAt != nil {
|
||||
claimedAtSQL = *claimedAt
|
||||
}
|
||||
var claimedBySQL interface{} = nil
|
||||
if claimedBy != "" {
|
||||
claimedBySQL = claimedBy
|
||||
}
|
||||
|
||||
result, err = db.Exec(
|
||||
`INSERT INTO messages (conversation_id, from_agent, to_agent, body, priority, status, metadata, claimed_by, claimed_at, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, 5, ?, '{}', ?, ?, ?, ?)`,
|
||||
convID, from, to, body, status, claimedBySQL, claimedAtSQL, createdAt, createdAt,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("insert stale message: %v", err)
|
||||
}
|
||||
id, _ := result.LastInsertId()
|
||||
return id
|
||||
}
|
||||
|
||||
func TestStalemateWorker_ProcessingTimeout(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Insert a message in "processing" status with old claimed_at
|
||||
oldClaimedAt := time.Now().Add(-25 * time.Hour)
|
||||
msgID := insertStaleMessage(t, db, "sender", "receiver", "stale processing task", StatusProcessing, time.Now().Add(-26*time.Hour), &oldClaimedAt, "receiver")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ProcessingTimeout = 24 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 0, err: fmt.Errorf("no channel")}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify message was auto-failed
|
||||
var status, metadata string
|
||||
err := db.QueryRowContext(ctx, `SELECT status, metadata FROM messages WHERE id = ?`, msgID).Scan(&status, &metadata)
|
||||
if err != nil {
|
||||
t.Fatalf("query message: %v", err)
|
||||
}
|
||||
if status != StatusFailed {
|
||||
t.Errorf("status = %q, want %q", status, StatusFailed)
|
||||
}
|
||||
if metadata == "{}" {
|
||||
t.Error("expected metadata to contain error info")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_ProcessingTimeout_NotExpired(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Insert a message in "processing" status with recent claimed_at (should NOT be failed)
|
||||
recentClaimedAt := time.Now().Add(-1 * time.Hour)
|
||||
msgID := insertStaleMessage(t, db, "sender", "receiver", "recent processing task", StatusProcessing, time.Now().Add(-2*time.Hour), &recentClaimedAt, "receiver")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ProcessingTimeout = 24 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 0, err: fmt.Errorf("no channel")}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify message was NOT auto-failed
|
||||
var status string
|
||||
err := db.QueryRowContext(ctx, `SELECT status FROM messages WHERE id = ?`, msgID).Scan(&status)
|
||||
if err != nil {
|
||||
t.Fatalf("query message: %v", err)
|
||||
}
|
||||
if status != StatusProcessing {
|
||||
t.Errorf("status = %q, want %q (should not have been failed)", status, StatusProcessing)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_PendingReminder(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Insert a pending DM that is 5 hours old
|
||||
insertStaleMessage(t, db, "sender", "receiver", "please review this", StatusPending, time.Now().Add(-5*time.Hour), nil, "")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ReminderAfter = 4 * time.Hour
|
||||
config.EscalateAfter = 48 * time.Hour // won't trigger
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 0, err: fmt.Errorf("no channel")}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify a system reminder was sent to receiver
|
||||
var count int
|
||||
err := db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE from_agent = 'system' AND to_agent = 'receiver' AND body LIKE '%Reminder%'`,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
t.Fatalf("query reminder: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Errorf("expected 1 reminder, got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_SystemMessageSkip(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Insert a pending DM FROM system (should be skipped)
|
||||
insertStaleMessage(t, db, "system", "receiver", "system notification", StatusPending, time.Now().Add(-5*time.Hour), nil, "")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ReminderAfter = 4 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 0, err: fmt.Errorf("no channel")}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify NO reminder was sent (only the original system message should exist)
|
||||
var count int
|
||||
err := db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE from_agent = 'system' AND body LIKE '%Reminder%'`,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
t.Fatalf("query reminder: %v", err)
|
||||
}
|
||||
if count != 0 {
|
||||
t.Errorf("expected 0 reminders for system message, got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_DuplicateReminderPrevention(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Insert a pending DM that is old enough for a reminder
|
||||
insertStaleMessage(t, db, "sender", "receiver", "need your attention", StatusPending, time.Now().Add(-5*time.Hour), nil, "")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ReminderAfter = 4 * time.Hour
|
||||
config.EscalateAfter = 48 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 0, err: fmt.Errorf("no channel")}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
// Run check twice
|
||||
worker.checkStaleMessages(ctx)
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify only ONE reminder was sent
|
||||
var count int
|
||||
err := db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE from_agent = 'system' AND to_agent = 'receiver' AND body LIKE '%Reminder%'`,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
t.Fatalf("query reminders: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Errorf("expected 1 reminder (no duplicates), got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_Escalation(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Create #approvals channel
|
||||
_, err := db.Exec(
|
||||
`INSERT INTO channels (id, name, description, topic, type, is_private, is_system, created_by, created_at, updated_at)
|
||||
VALUES (1, 'approvals', 'Approval queue', '', 'standard', 0, 0, 'system', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("create approvals channel: %v", err)
|
||||
}
|
||||
// Add system as member
|
||||
_, err = db.Exec(
|
||||
`INSERT INTO channel_members (channel_id, agent_name, role, joined_at)
|
||||
VALUES (1, 'system', 'owner', CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("add system to channel: %v", err)
|
||||
}
|
||||
|
||||
// Insert a pending DM that is 49 hours old (beyond escalation threshold)
|
||||
insertStaleMessage(t, db, "sender", "receiver", "urgent task ignored", StatusPending, time.Now().Add(-49*time.Hour), nil, "")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ReminderAfter = 4 * time.Hour
|
||||
config.EscalateAfter = 48 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 1}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify an escalation was sent to #approvals channel
|
||||
var count int
|
||||
err = db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE from_agent = 'system' AND channel_id = 1 AND body LIKE '%ESCALATION%'`,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
t.Fatalf("query escalations: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Errorf("expected 1 escalation, got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStalemateWorker_DuplicateEscalationPrevention(t *testing.T) {
|
||||
svc, db := newStalemateTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
// Create #approvals channel
|
||||
db.Exec(
|
||||
`INSERT INTO channels (id, name, description, topic, type, is_private, is_system, created_by, created_at, updated_at)
|
||||
VALUES (1, 'approvals', 'Approval queue', '', 'standard', 0, 0, 'system', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
|
||||
db.Exec(
|
||||
`INSERT INTO channel_members (channel_id, agent_name, role, joined_at)
|
||||
VALUES (1, 'system', 'owner', CURRENT_TIMESTAMP)`)
|
||||
|
||||
// Insert a pending DM that is 49 hours old
|
||||
insertStaleMessage(t, db, "sender", "receiver", "urgent task", StatusPending, time.Now().Add(-49*time.Hour), nil, "")
|
||||
|
||||
config := DefaultStalemateConfig()
|
||||
config.ReminderAfter = 4 * time.Hour
|
||||
config.EscalateAfter = 48 * time.Hour
|
||||
|
||||
lookup := &stubChannelLookup{channelID: 1}
|
||||
worker := NewStalemateWorker(db, svc, lookup, config)
|
||||
|
||||
// Run check twice
|
||||
worker.checkStaleMessages(ctx)
|
||||
worker.checkStaleMessages(ctx)
|
||||
|
||||
// Verify only ONE escalation was sent
|
||||
var count int
|
||||
err := db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE from_agent = 'system' AND channel_id = 1 AND body LIKE '%ESCALATION%'`,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
t.Fatalf("query escalations: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Errorf("expected 1 escalation (no duplicates), got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseStalemateConfig(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
envVars map[string]string
|
||||
expected StalemateConfig
|
||||
}{
|
||||
{
|
||||
name: "defaults when no env vars",
|
||||
envVars: map[string]string{},
|
||||
expected: DefaultStalemateConfig(),
|
||||
},
|
||||
{
|
||||
name: "custom values with day format",
|
||||
envVars: map[string]string{
|
||||
"SYNAPBUS_STALEMATE_PROCESSING_TIMEOUT": "7d",
|
||||
"SYNAPBUS_STALEMATE_REMINDER_AFTER": "8h",
|
||||
"SYNAPBUS_STALEMATE_ESCALATE_AFTER": "3d",
|
||||
"SYNAPBUS_STALEMATE_INTERVAL": "30m",
|
||||
},
|
||||
expected: StalemateConfig{
|
||||
ProcessingTimeout: 7 * 24 * time.Hour,
|
||||
ReminderAfter: 8 * time.Hour,
|
||||
EscalateAfter: 3 * 24 * time.Hour,
|
||||
Interval: 30 * time.Minute,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "standard Go duration format",
|
||||
envVars: map[string]string{
|
||||
"SYNAPBUS_STALEMATE_PROCESSING_TIMEOUT": "48h",
|
||||
"SYNAPBUS_STALEMATE_REMINDER_AFTER": "2h30m",
|
||||
"SYNAPBUS_STALEMATE_ESCALATE_AFTER": "72h",
|
||||
"SYNAPBUS_STALEMATE_INTERVAL": "5m",
|
||||
},
|
||||
expected: StalemateConfig{
|
||||
ProcessingTimeout: 48 * time.Hour,
|
||||
ReminderAfter: 2*time.Hour + 30*time.Minute,
|
||||
EscalateAfter: 72 * time.Hour,
|
||||
Interval: 5 * time.Minute,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "invalid values fall back to defaults",
|
||||
envVars: map[string]string{
|
||||
"SYNAPBUS_STALEMATE_PROCESSING_TIMEOUT": "invalid",
|
||||
"SYNAPBUS_STALEMATE_REMINDER_AFTER": "bad",
|
||||
"SYNAPBUS_STALEMATE_ESCALATE_AFTER": "",
|
||||
"SYNAPBUS_STALEMATE_INTERVAL": "-5m",
|
||||
},
|
||||
expected: DefaultStalemateConfig(),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Clear all env vars first
|
||||
envKeys := []string{
|
||||
"SYNAPBUS_STALEMATE_PROCESSING_TIMEOUT",
|
||||
"SYNAPBUS_STALEMATE_REMINDER_AFTER",
|
||||
"SYNAPBUS_STALEMATE_ESCALATE_AFTER",
|
||||
"SYNAPBUS_STALEMATE_INTERVAL",
|
||||
}
|
||||
for _, k := range envKeys {
|
||||
os.Unsetenv(k)
|
||||
}
|
||||
|
||||
// Set test env vars
|
||||
for k, v := range tt.envVars {
|
||||
os.Setenv(k, v)
|
||||
}
|
||||
defer func() {
|
||||
for _, k := range envKeys {
|
||||
os.Unsetenv(k)
|
||||
}
|
||||
}()
|
||||
|
||||
cfg := ParseStalemateConfig()
|
||||
|
||||
if cfg.ProcessingTimeout != tt.expected.ProcessingTimeout {
|
||||
t.Errorf("ProcessingTimeout = %v, want %v", cfg.ProcessingTimeout, tt.expected.ProcessingTimeout)
|
||||
}
|
||||
if cfg.ReminderAfter != tt.expected.ReminderAfter {
|
||||
t.Errorf("ReminderAfter = %v, want %v", cfg.ReminderAfter, tt.expected.ReminderAfter)
|
||||
}
|
||||
if cfg.EscalateAfter != tt.expected.EscalateAfter {
|
||||
t.Errorf("EscalateAfter = %v, want %v", cfg.EscalateAfter, tt.expected.EscalateAfter)
|
||||
}
|
||||
if cfg.Interval != tt.expected.Interval {
|
||||
t.Errorf("Interval = %v, want %v", cfg.Interval, tt.expected.Interval)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDurationWithDays(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
want time.Duration
|
||||
wantErr bool
|
||||
}{
|
||||
{"7 days", "7d", 7 * 24 * time.Hour, false},
|
||||
{"1 day", "1d", 24 * time.Hour, false},
|
||||
{"30 days", "30d", 30 * 24 * time.Hour, false},
|
||||
{"standard hours", "48h", 48 * time.Hour, false},
|
||||
{"standard minutes", "15m", 15 * time.Minute, false},
|
||||
{"mixed duration", "2h30m", 2*time.Hour + 30*time.Minute, false},
|
||||
{"empty string", "", 0, true},
|
||||
{"invalid", "xyz", 0, true},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := parseDurationWithDays(tt.input)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("parseDurationWithDays(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("parseDurationWithDays(%q) = %v, want %v", tt.input, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTruncate(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
maxLen int
|
||||
want string
|
||||
}{
|
||||
{"short string", "hello", 10, "hello"},
|
||||
{"exact length", "hello", 5, "hello"},
|
||||
{"truncated", "hello world, this is a long message", 10, "hello worl..."},
|
||||
{"empty", "", 10, ""},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := truncate(tt.input, tt.maxLen)
|
||||
if got != tt.want {
|
||||
t.Errorf("truncate(%q, %d) = %q, want %q", tt.input, tt.maxLen, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormatAge(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
d time.Duration
|
||||
want string
|
||||
}{
|
||||
{"minutes", 30 * time.Minute, "30m"},
|
||||
{"hours", 5 * time.Hour, "5h"},
|
||||
{"1 day", 24 * time.Hour, "1 day"},
|
||||
{"2 days", 48 * time.Hour, "2 days"},
|
||||
{"1 day with hours", 25 * time.Hour, "1 day 1h"},
|
||||
{"2 days with hours", 50 * time.Hour, "2 days 2h"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := formatAge(tt.d)
|
||||
if got != tt.want {
|
||||
t.Errorf("formatAge(%v) = %q, want %q", tt.d, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
+396
-46
@@ -6,6 +6,7 @@ import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// MessageStore defines the storage interface for messaging operations.
|
||||
@@ -14,22 +15,30 @@ type MessageStore interface {
|
||||
InsertConversation(ctx context.Context, conv *Conversation) error
|
||||
FindConversation(ctx context.Context, subject, fromAgent, toAgent string) (*Conversation, error)
|
||||
GetInboxMessages(ctx context.Context, agentName string, opts ReadOptions) ([]*Message, error)
|
||||
CountInboxMessages(ctx context.Context, agentName string, opts ReadOptions) (int, error)
|
||||
GetInboxState(ctx context.Context, agentName string, conversationID int64) (*InboxState, error)
|
||||
UpdateInboxState(ctx context.Context, agentName string, conversationID int64, lastReadMsgID int64) error
|
||||
ClaimMessages(ctx context.Context, agentName string, limit int) ([]*Message, error)
|
||||
UpdateMessageStatus(ctx context.Context, id int64, status, claimedBy string, metadata json.RawMessage) error
|
||||
GetMessageByID(ctx context.Context, id int64) (*Message, error)
|
||||
SearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) ([]*Message, error)
|
||||
CountSearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) (int, error)
|
||||
GetConversation(ctx context.Context, id int64) (*Conversation, error)
|
||||
GetConversationMessages(ctx context.Context, conversationID int64) ([]*Message, error)
|
||||
GetReplies(ctx context.Context, messageID int64) ([]*Message, error)
|
||||
GetChannelMessages(ctx context.Context, channelID int64, limit int) ([]*Message, error)
|
||||
GetChannelMessages(ctx context.Context, channelID int64, limit, offset int) ([]*Message, error)
|
||||
CountChannelMessages(ctx context.Context, channelID int64) (int, error)
|
||||
GetDMMessages(ctx context.Context, agents []string, peerAgent string, limit int) ([]*Message, error)
|
||||
AgentExists(ctx context.Context, agentName string) (bool, error)
|
||||
CountPendingDMs(ctx context.Context, agentName string) (int64, error)
|
||||
GetPendingDMs(ctx context.Context, agentName string, limit int) ([]*Message, error)
|
||||
GetRecentMentions(ctx context.Context, agentName string, limit int) ([]*Message, error)
|
||||
GetSystemNotifications(ctx context.Context, agentName string, limit int) ([]*Message, error)
|
||||
GetDMUnreadCounts(ctx context.Context, agentName string) ([]DMUnreadCount, error)
|
||||
GetLastReadForChannel(ctx context.Context, agentName string, channelID int64) (int64, error)
|
||||
GetLastReadForDM(ctx context.Context, agentNames []string, peerAgent string) (int64, error)
|
||||
GetConversationIDsForChannel(ctx context.Context, channelID int64, lastMessageID int64) ([]int64, error)
|
||||
GetConversationIDsForDM(ctx context.Context, agentNames []string, peerAgent string, lastMessageID int64) ([]int64, error)
|
||||
}
|
||||
|
||||
// SQLiteMessageStore implements MessageStore using SQLite.
|
||||
@@ -115,6 +124,58 @@ func (s *SQLiteMessageStore) InsertMessage(ctx context.Context, msg *Message) er
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) GetInboxMessages(ctx context.Context, agentName string, opts ReadOptions) ([]*Message, error) {
|
||||
conditions, args := s.buildInboxConditions(agentName, opts)
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
|
||||
offset := opts.Offset
|
||||
if offset < 0 {
|
||||
offset = 0
|
||||
}
|
||||
|
||||
query := fmt.Sprintf(
|
||||
`SELECT m.id, m.conversation_id, m.from_agent, m.to_agent, m.channel_id,
|
||||
m.body, m.priority, m.status, m.metadata, m.claimed_by, m.claimed_at,
|
||||
m.created_at, m.updated_at, m.reply_to
|
||||
FROM messages m
|
||||
WHERE %s
|
||||
ORDER BY m.priority DESC, m.created_at ASC
|
||||
LIMIT ? OFFSET ?`,
|
||||
strings.Join(conditions, " AND "),
|
||||
)
|
||||
args = append(args, limit, offset)
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, query, args...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("query inbox: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
return scanMessages(rows)
|
||||
}
|
||||
|
||||
// CountInboxMessages returns the total count of inbox messages matching the given options.
|
||||
func (s *SQLiteMessageStore) CountInboxMessages(ctx context.Context, agentName string, opts ReadOptions) (int, error) {
|
||||
conditions, args := s.buildInboxConditions(agentName, opts)
|
||||
|
||||
query := fmt.Sprintf(
|
||||
`SELECT COUNT(*) FROM messages m WHERE %s`,
|
||||
strings.Join(conditions, " AND "),
|
||||
)
|
||||
|
||||
var count int
|
||||
err := s.db.QueryRowContext(ctx, query, args...).Scan(&count)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("count inbox messages: %w", err)
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// buildInboxConditions builds the WHERE conditions and args for inbox queries.
|
||||
func (s *SQLiteMessageStore) buildInboxConditions(agentName string, opts ReadOptions) ([]string, []any) {
|
||||
var conditions []string
|
||||
var args []any
|
||||
|
||||
@@ -151,30 +212,21 @@ func (s *SQLiteMessageStore) GetInboxMessages(ctx context.Context, agentName str
|
||||
args = append(args, opts.MinPriority)
|
||||
}
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
if opts.After != "" {
|
||||
if t, err := time.Parse(time.RFC3339, opts.After); err == nil {
|
||||
conditions = append(conditions, "m.created_at >= ?")
|
||||
args = append(args, t.UTC().Format("2006-01-02 15:04:05"))
|
||||
}
|
||||
}
|
||||
|
||||
query := fmt.Sprintf(
|
||||
`SELECT m.id, m.conversation_id, m.from_agent, m.to_agent, m.channel_id,
|
||||
m.body, m.priority, m.status, m.metadata, m.claimed_by, m.claimed_at,
|
||||
m.created_at, m.updated_at, m.reply_to
|
||||
FROM messages m
|
||||
WHERE %s
|
||||
ORDER BY m.priority DESC, m.created_at ASC
|
||||
LIMIT ?`,
|
||||
strings.Join(conditions, " AND "),
|
||||
)
|
||||
args = append(args, limit)
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, query, args...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("query inbox: %w", err)
|
||||
if opts.Before != "" {
|
||||
if t, err := time.Parse(time.RFC3339, opts.Before); err == nil {
|
||||
conditions = append(conditions, "m.created_at <= ?")
|
||||
args = append(args, t.UTC().Format("2006-01-02 15:04:05"))
|
||||
}
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
return scanMessages(rows)
|
||||
return conditions, args
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) GetInboxState(ctx context.Context, agentName string, conversationID int64) (*InboxState, error) {
|
||||
@@ -333,6 +385,62 @@ func (s *SQLiteMessageStore) GetMessageByID(ctx context.Context, id int64) (*Mes
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) SearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) ([]*Message, error) {
|
||||
conditions, args, joinClause, orderClause := s.buildSearchConditions(agentName, query, opts)
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 20
|
||||
}
|
||||
|
||||
offset := opts.Offset
|
||||
if offset < 0 {
|
||||
offset = 0
|
||||
}
|
||||
|
||||
querySQL := fmt.Sprintf(
|
||||
`SELECT m.id, m.conversation_id, m.from_agent, m.to_agent, m.channel_id,
|
||||
m.body, m.priority, m.status, m.metadata, m.claimed_by, m.claimed_at,
|
||||
m.created_at, m.updated_at, m.reply_to
|
||||
FROM messages m
|
||||
%s
|
||||
WHERE %s
|
||||
%s
|
||||
LIMIT ? OFFSET ?`,
|
||||
joinClause,
|
||||
strings.Join(conditions, " AND "),
|
||||
orderClause,
|
||||
)
|
||||
args = append(args, limit, offset)
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, querySQL, args...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("search messages: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
return scanMessages(rows)
|
||||
}
|
||||
|
||||
// CountSearchMessages returns the total count of messages matching the search criteria.
|
||||
func (s *SQLiteMessageStore) CountSearchMessages(ctx context.Context, agentName, query string, opts SearchOptions) (int, error) {
|
||||
conditions, args, joinClause, _ := s.buildSearchConditions(agentName, query, opts)
|
||||
|
||||
countSQL := fmt.Sprintf(
|
||||
`SELECT COUNT(*) FROM messages m %s WHERE %s`,
|
||||
joinClause,
|
||||
strings.Join(conditions, " AND "),
|
||||
)
|
||||
|
||||
var count int
|
||||
err := s.db.QueryRowContext(ctx, countSQL, args...).Scan(&count)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("count search messages: %w", err)
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// buildSearchConditions builds the WHERE conditions, args, JOIN clause, and ORDER clause for search queries.
|
||||
func (s *SQLiteMessageStore) buildSearchConditions(agentName, query string, opts SearchOptions) ([]string, []any, string, string) {
|
||||
var conditions []string
|
||||
var args []any
|
||||
|
||||
@@ -374,33 +482,82 @@ func (s *SQLiteMessageStore) SearchMessages(ctx context.Context, agentName, quer
|
||||
args = append(args, opts.Status)
|
||||
}
|
||||
|
||||
limit := opts.Limit
|
||||
if limit <= 0 {
|
||||
limit = 20
|
||||
if opts.ChannelID != nil {
|
||||
conditions = append(conditions, "m.channel_id = ?")
|
||||
args = append(args, *opts.ChannelID)
|
||||
}
|
||||
|
||||
querySQL := fmt.Sprintf(
|
||||
`SELECT m.id, m.conversation_id, m.from_agent, m.to_agent, m.channel_id,
|
||||
m.body, m.priority, m.status, m.metadata, m.claimed_by, m.claimed_at,
|
||||
m.created_at, m.updated_at, m.reply_to
|
||||
FROM messages m
|
||||
%s
|
||||
WHERE %s
|
||||
%s
|
||||
LIMIT ?`,
|
||||
joinClause,
|
||||
strings.Join(conditions, " AND "),
|
||||
orderClause,
|
||||
)
|
||||
args = append(args, limit)
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, querySQL, args...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("search messages: %w", err)
|
||||
if opts.Channel != "" {
|
||||
conditions = append(conditions, "m.channel_id IN (SELECT id FROM channels WHERE LOWER(name) = LOWER(?))")
|
||||
args = append(args, opts.Channel)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
return scanMessages(rows)
|
||||
if len(opts.Channels) > 0 {
|
||||
placeholders := make([]string, len(opts.Channels))
|
||||
for i, ch := range opts.Channels {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, ch)
|
||||
}
|
||||
conditions = append(conditions, fmt.Sprintf("m.channel_id IN (SELECT id FROM channels WHERE LOWER(name) IN (%s))", strings.Join(placeholders, ",")))
|
||||
}
|
||||
|
||||
if len(opts.ExcludeChannels) > 0 {
|
||||
placeholders := make([]string, len(opts.ExcludeChannels))
|
||||
for i, ch := range opts.ExcludeChannels {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, ch)
|
||||
}
|
||||
conditions = append(conditions, fmt.Sprintf("(m.channel_id IS NULL OR m.channel_id NOT IN (SELECT id FROM channels WHERE LOWER(name) IN (%s)))", strings.Join(placeholders, ",")))
|
||||
}
|
||||
|
||||
if len(opts.Agents) > 0 {
|
||||
placeholders := make([]string, len(opts.Agents))
|
||||
for i, a := range opts.Agents {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause := strings.Join(placeholders, ",")
|
||||
// Clone placeholders for the second IN clause
|
||||
placeholders2 := make([]string, len(opts.Agents))
|
||||
for i, a := range opts.Agents {
|
||||
placeholders2[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause2 := strings.Join(placeholders2, ",")
|
||||
conditions = append(conditions, fmt.Sprintf("(m.from_agent IN (%s) OR m.to_agent IN (%s))", inClause, inClause2))
|
||||
}
|
||||
|
||||
if len(opts.ExcludeAgents) > 0 {
|
||||
placeholders := make([]string, len(opts.ExcludeAgents))
|
||||
for i, a := range opts.ExcludeAgents {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause := strings.Join(placeholders, ",")
|
||||
placeholders2 := make([]string, len(opts.ExcludeAgents))
|
||||
for i, a := range opts.ExcludeAgents {
|
||||
placeholders2[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause2 := strings.Join(placeholders2, ",")
|
||||
conditions = append(conditions, fmt.Sprintf("m.from_agent NOT IN (%s) AND (m.to_agent = '' OR m.to_agent NOT IN (%s))", inClause, inClause2))
|
||||
}
|
||||
|
||||
if opts.After != "" {
|
||||
if t, err := time.Parse(time.RFC3339, opts.After); err == nil {
|
||||
conditions = append(conditions, "m.created_at >= ?")
|
||||
args = append(args, t.UTC().Format("2006-01-02 15:04:05"))
|
||||
}
|
||||
}
|
||||
|
||||
if opts.Before != "" {
|
||||
if t, err := time.Parse(time.RFC3339, opts.Before); err == nil {
|
||||
conditions = append(conditions, "m.created_at <= ?")
|
||||
args = append(args, t.UTC().Format("2006-01-02 15:04:05"))
|
||||
}
|
||||
}
|
||||
|
||||
return conditions, args, joinClause, orderClause
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) GetConversation(ctx context.Context, id int64) (*Conversation, error) {
|
||||
@@ -451,17 +608,20 @@ func (s *SQLiteMessageStore) GetReplies(ctx context.Context, messageID int64) ([
|
||||
return scanMessages(rows)
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) GetChannelMessages(ctx context.Context, channelID int64, limit int) ([]*Message, error) {
|
||||
func (s *SQLiteMessageStore) GetChannelMessages(ctx context.Context, channelID int64, limit, offset int) ([]*Message, error) {
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
if offset < 0 {
|
||||
offset = 0
|
||||
}
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, conversation_id, from_agent, to_agent, channel_id,
|
||||
body, priority, status, metadata, claimed_by, claimed_at,
|
||||
created_at, updated_at, reply_to
|
||||
FROM messages WHERE channel_id = ?
|
||||
ORDER BY created_at ASC
|
||||
LIMIT ?`, channelID, limit,
|
||||
LIMIT ? OFFSET ?`, channelID, limit, offset,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get channel messages: %w", err)
|
||||
@@ -470,6 +630,18 @@ func (s *SQLiteMessageStore) GetChannelMessages(ctx context.Context, channelID i
|
||||
return scanMessages(rows)
|
||||
}
|
||||
|
||||
// CountChannelMessages returns the total number of messages in a channel.
|
||||
func (s *SQLiteMessageStore) CountChannelMessages(ctx context.Context, channelID int64) (int, error) {
|
||||
var count int
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM messages WHERE channel_id = ?`, channelID,
|
||||
).Scan(&count)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("count channel messages: %w", err)
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
func (s *SQLiteMessageStore) GetDMMessages(ctx context.Context, agents []string, peerAgent string, limit int) ([]*Message, error) {
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
@@ -657,6 +829,184 @@ func scanMessageFromRows(rows *sql.Rows) (*Message, error) {
|
||||
return &msg, nil
|
||||
}
|
||||
|
||||
// GetDMUnreadCounts returns unread DM counts grouped by peer agent.
|
||||
// For each unique from_agent that has sent DMs to agentName, it computes
|
||||
// how many messages have id > last_read_message_id (from inbox_state).
|
||||
func (s *SQLiteMessageStore) GetDMUnreadCounts(ctx context.Context, agentName string) ([]DMUnreadCount, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT
|
||||
m.from_agent,
|
||||
COUNT(CASE WHEN m.id > COALESCE(
|
||||
(SELECT ist.last_read_message_id FROM inbox_state ist
|
||||
WHERE ist.agent_name = ? AND ist.conversation_id = m.conversation_id), 0)
|
||||
THEN 1 END) AS unread_count,
|
||||
MAX(m.id) AS last_message_id
|
||||
FROM messages m
|
||||
WHERE m.to_agent = ?
|
||||
AND m.channel_id IS NULL
|
||||
AND m.from_agent != 'system'
|
||||
GROUP BY m.from_agent
|
||||
ORDER BY m.from_agent`,
|
||||
agentName, agentName,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get dm unread counts: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var results []DMUnreadCount
|
||||
for rows.Next() {
|
||||
var d DMUnreadCount
|
||||
if err := rows.Scan(&d.Agent, &d.UnreadCount, &d.LastMessageID); err != nil {
|
||||
return nil, fmt.Errorf("scan dm unread count: %w", err)
|
||||
}
|
||||
results = append(results, d)
|
||||
}
|
||||
if results == nil {
|
||||
results = []DMUnreadCount{}
|
||||
}
|
||||
return results, rows.Err()
|
||||
}
|
||||
|
||||
// GetLastReadForChannel returns the effective last_read_message_id for an agent
|
||||
// across all conversations in a given channel.
|
||||
func (s *SQLiteMessageStore) GetLastReadForChannel(ctx context.Context, agentName string, channelID int64) (int64, error) {
|
||||
var lastRead sql.NullInt64
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT MIN(COALESCE(ist.last_read_message_id, 0))
|
||||
FROM (SELECT DISTINCT conversation_id FROM messages WHERE channel_id = ?) conv
|
||||
LEFT JOIN inbox_state ist ON ist.conversation_id = conv.conversation_id AND ist.agent_name = ?`,
|
||||
channelID, agentName,
|
||||
).Scan(&lastRead)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("get last read for channel: %w", err)
|
||||
}
|
||||
if lastRead.Valid {
|
||||
return lastRead.Int64, nil
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// GetLastReadForDM returns the effective last_read_message_id for an owned agent
|
||||
// in DM conversations with a specific peer agent.
|
||||
func (s *SQLiteMessageStore) GetLastReadForDM(ctx context.Context, agentNames []string, peerAgent string) (int64, error) {
|
||||
if len(agentNames) == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
placeholders := make([]string, len(agentNames))
|
||||
args := make([]any, 0, len(agentNames)*2+1)
|
||||
for i, a := range agentNames {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause := strings.Join(placeholders, ",")
|
||||
|
||||
// Find conversations between owned agents and peer agent (DMs only)
|
||||
// and get the max last_read_message_id
|
||||
query := fmt.Sprintf(
|
||||
`SELECT COALESCE(MAX(ist.last_read_message_id), 0)
|
||||
FROM inbox_state ist
|
||||
WHERE ist.agent_name IN (%s)
|
||||
AND ist.conversation_id IN (
|
||||
SELECT DISTINCT m.conversation_id FROM messages m
|
||||
WHERE m.channel_id IS NULL
|
||||
AND ((m.from_agent IN (%s) AND m.to_agent = ?)
|
||||
OR (m.from_agent = ? AND m.to_agent IN (%s)))
|
||||
)`,
|
||||
inClause, inClause, inClause,
|
||||
)
|
||||
for _, a := range agentNames {
|
||||
args = append(args, a)
|
||||
}
|
||||
args = append(args, peerAgent, peerAgent)
|
||||
for _, a := range agentNames {
|
||||
args = append(args, a)
|
||||
}
|
||||
|
||||
var lastRead int64
|
||||
err := s.db.QueryRowContext(ctx, query, args...).Scan(&lastRead)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("get last read for dm: %w", err)
|
||||
}
|
||||
return lastRead, nil
|
||||
}
|
||||
|
||||
// GetConversationIDsForChannel returns conversation IDs in a channel with messages up to lastMessageID.
|
||||
func (s *SQLiteMessageStore) GetConversationIDsForChannel(ctx context.Context, channelID int64, lastMessageID int64) ([]int64, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT DISTINCT conversation_id FROM messages
|
||||
WHERE channel_id = ? AND id <= ?`,
|
||||
channelID, lastMessageID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get conversation ids for channel: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var ids []int64
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, fmt.Errorf("scan conversation id: %w", err)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, rows.Err()
|
||||
}
|
||||
|
||||
// GetConversationIDsForDM returns conversation IDs for DMs between owned agents and a peer agent,
|
||||
// with messages up to lastMessageID.
|
||||
func (s *SQLiteMessageStore) GetConversationIDsForDM(ctx context.Context, agentNames []string, peerAgent string, lastMessageID int64) ([]int64, error) {
|
||||
if len(agentNames) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
placeholders := make([]string, len(agentNames))
|
||||
args := make([]any, 0, len(agentNames)*2+2)
|
||||
for i, a := range agentNames {
|
||||
placeholders[i] = "?"
|
||||
args = append(args, a)
|
||||
}
|
||||
inClause := strings.Join(placeholders, ",")
|
||||
|
||||
query := fmt.Sprintf(
|
||||
`SELECT DISTINCT conversation_id FROM messages
|
||||
WHERE channel_id IS NULL
|
||||
AND id <= ?
|
||||
AND ((from_agent IN (%s) AND to_agent = ?)
|
||||
OR (from_agent = ? AND to_agent IN (%s)))`,
|
||||
inClause, inClause,
|
||||
)
|
||||
|
||||
// Reorder args: agentNames for first IN, lastMessageID, agentNames for second IN...
|
||||
finalArgs := make([]any, 0, len(agentNames)*2+3)
|
||||
finalArgs = append(finalArgs, lastMessageID)
|
||||
for _, a := range agentNames {
|
||||
finalArgs = append(finalArgs, a)
|
||||
}
|
||||
finalArgs = append(finalArgs, peerAgent, peerAgent)
|
||||
for _, a := range agentNames {
|
||||
finalArgs = append(finalArgs, a)
|
||||
}
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, query, finalArgs...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get conversation ids for dm: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var ids []int64
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, fmt.Errorf("scan conversation id: %w", err)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, rows.Err()
|
||||
}
|
||||
|
||||
// scanMessage scans a single message from sql.Row.
|
||||
func scanMessage(row *sql.Row) (*Message, error) {
|
||||
var msg Message
|
||||
|
||||
@@ -534,3 +534,561 @@ func TestSQLiteMessageStore_AgentExists(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_GetInboxMessages_Offset(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "reader")
|
||||
|
||||
conv := &Conversation{Subject: "offset test", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
// Insert 5 messages
|
||||
for i := 0; i < 5; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "reader",
|
||||
Body: fmt.Sprintf("msg %d", i),
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("offset=0 returns from beginning", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
Limit: 2,
|
||||
Offset: 0,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset=2 skips first 2", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
Limit: 2,
|
||||
Offset: 2,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset beyond total returns empty", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
Limit: 10,
|
||||
Offset: 100,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 0 {
|
||||
t.Errorf("got %d messages, want 0", len(messages))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_CountInboxMessages(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "counter")
|
||||
|
||||
conv := &Conversation{Subject: "count test", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "counter",
|
||||
Body: "msg",
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
count, err := store.CountInboxMessages(ctx, "counter", ReadOptions{IncludeRead: true})
|
||||
if err != nil {
|
||||
t.Fatalf("CountInboxMessages: %v", err)
|
||||
}
|
||||
if count != 5 {
|
||||
t.Errorf("count = %d, want 5", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_SearchMessages_Offset(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "searcher")
|
||||
|
||||
conv := &Conversation{Subject: "search offset test", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "searcher",
|
||||
Body: fmt.Sprintf("unique message %d", i),
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("offset=0 limit=2 returns first 2", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "searcher", "", SearchOptions{
|
||||
Limit: 2,
|
||||
Offset: 0,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset=3 returns remaining 2", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "searcher", "", SearchOptions{
|
||||
Limit: 10,
|
||||
Offset: 3,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset beyond total returns empty", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "searcher", "", SearchOptions{
|
||||
Limit: 10,
|
||||
Offset: 100,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 0 {
|
||||
t.Errorf("got %d results, want 0", len(results))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_CountSearchMessages(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "searcher")
|
||||
|
||||
conv := &Conversation{Subject: "count search", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < 3; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "searcher",
|
||||
Body: fmt.Sprintf("deployment issue %d", i),
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
count, err := store.CountSearchMessages(ctx, "searcher", "deployment", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("CountSearchMessages: %v", err)
|
||||
}
|
||||
if count != 3 {
|
||||
t.Errorf("count = %d, want 3", count)
|
||||
}
|
||||
|
||||
count, err = store.CountSearchMessages(ctx, "searcher", "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("CountSearchMessages: %v", err)
|
||||
}
|
||||
if count != 3 {
|
||||
t.Errorf("count = %d, want 3", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_DateFiltering(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "reader")
|
||||
|
||||
conv := &Conversation{Subject: "date test", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
// Insert messages (all at "now" since SQLite uses CURRENT_TIMESTAMP)
|
||||
for i := 0; i < 3; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "reader",
|
||||
Body: fmt.Sprintf("dated msg %d", i),
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("after in the past returns all", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
IncludeRead: true,
|
||||
After: "2020-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 3 {
|
||||
t.Errorf("got %d messages, want 3", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("after in the future returns none", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
IncludeRead: true,
|
||||
After: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 0 {
|
||||
t.Errorf("got %d messages, want 0", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("before in the past returns none", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
IncludeRead: true,
|
||||
Before: "2020-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 0 {
|
||||
t.Errorf("got %d messages, want 0", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("before in the future returns all", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
IncludeRead: true,
|
||||
Before: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 3 {
|
||||
t.Errorf("got %d messages, want 3", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("combined after+before", func(t *testing.T) {
|
||||
messages, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
IncludeRead: true,
|
||||
After: "2020-01-01T00:00:00Z",
|
||||
Before: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 3 {
|
||||
t.Errorf("got %d messages, want 3", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("search date filtering", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "reader", "", SearchOptions{
|
||||
After: "2020-01-01T00:00:00Z",
|
||||
Before: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 3 {
|
||||
t.Errorf("got %d results, want 3", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("search after in the future returns none", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "reader", "", SearchOptions{
|
||||
After: "2099-01-01T00:00:00Z",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 0 {
|
||||
t.Errorf("got %d results, want 0", len(results))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_SearchMessages_ChannelFilter(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "agent-a")
|
||||
|
||||
// Create a channel
|
||||
_, err := db.ExecContext(ctx,
|
||||
`INSERT INTO channels (id, name, description, topic, type, is_private, is_system, created_by, created_at, updated_at)
|
||||
VALUES (1, 'test-channel', '', '', 'standard', 0, 0, 'agent-a', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("create channel: %v", err)
|
||||
}
|
||||
|
||||
// Add agent as member
|
||||
_, err = db.ExecContext(ctx,
|
||||
`INSERT INTO channel_members (channel_id, agent_name, role, joined_at)
|
||||
VALUES (1, 'agent-a', 'owner', CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("add member: %v", err)
|
||||
}
|
||||
|
||||
conv := &Conversation{Subject: "channel test", CreatedBy: "agent-a"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
chID := int64(1)
|
||||
// Insert a channel message
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "agent-a",
|
||||
ChannelID: &chID,
|
||||
Body: "channel message",
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
|
||||
// Insert a DM (not in channel)
|
||||
seedAgent(t, db, "agent-b")
|
||||
convDM := &Conversation{Subject: "dm test", CreatedBy: "agent-a"}
|
||||
if err := store.InsertConversation(ctx, convDM); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
dmMsg := &Message{
|
||||
ConversationID: convDM.ID,
|
||||
FromAgent: "agent-a",
|
||||
ToAgent: "agent-b",
|
||||
Body: "dm message",
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, dmMsg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
|
||||
t.Run("filter by channel name", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "agent-a", "", SearchOptions{
|
||||
Channel: "test-channel",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 1 {
|
||||
t.Errorf("got %d results, want 1", len(results))
|
||||
}
|
||||
if len(results) > 0 && results[0].Body != "channel message" {
|
||||
t.Errorf("body = %q, want %q", results[0].Body, "channel message")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-existent channel returns empty", func(t *testing.T) {
|
||||
results, err := store.SearchMessages(ctx, "agent-a", "", SearchOptions{
|
||||
Channel: "no-such-channel",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchMessages: %v", err)
|
||||
}
|
||||
if len(results) != 0 {
|
||||
t.Errorf("got %d results, want 0", len(results))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_GetChannelMessages_Offset(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "agent-a")
|
||||
|
||||
// Create a channel
|
||||
_, err := db.ExecContext(ctx,
|
||||
`INSERT INTO channels (id, name, description, topic, type, is_private, is_system, created_by, created_at, updated_at)
|
||||
VALUES (1, 'offset-channel', '', '', 'standard', 0, 0, 'agent-a', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
|
||||
if err != nil {
|
||||
t.Fatalf("create channel: %v", err)
|
||||
}
|
||||
|
||||
conv := &Conversation{Subject: "ch offset", CreatedBy: "agent-a"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
chID := int64(1)
|
||||
for i := 0; i < 5; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "agent-a",
|
||||
ChannelID: &chID,
|
||||
Body: fmt.Sprintf("ch msg %d", i),
|
||||
Priority: 5,
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("offset=0 limit=3", func(t *testing.T) {
|
||||
messages, err := store.GetChannelMessages(ctx, 1, 3, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("GetChannelMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 3 {
|
||||
t.Errorf("got %d messages, want 3", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("offset=3 returns remaining", func(t *testing.T) {
|
||||
messages, err := store.GetChannelMessages(ctx, 1, 10, 3)
|
||||
if err != nil {
|
||||
t.Fatalf("GetChannelMessages: %v", err)
|
||||
}
|
||||
if len(messages) != 2 {
|
||||
t.Errorf("got %d messages, want 2", len(messages))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("count channel messages", func(t *testing.T) {
|
||||
count, err := store.CountChannelMessages(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("CountChannelMessages: %v", err)
|
||||
}
|
||||
if count != 5 {
|
||||
t.Errorf("count = %d, want 5", count)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSQLiteMessageStore_CombinedFiltersAndPagination(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteMessageStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
seedAgent(t, db, "sender")
|
||||
seedAgent(t, db, "reader")
|
||||
|
||||
conv := &Conversation{Subject: "combined", CreatedBy: "sender"}
|
||||
if err := store.InsertConversation(ctx, conv); err != nil {
|
||||
t.Fatalf("InsertConversation: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
msg := &Message{
|
||||
ConversationID: conv.ID,
|
||||
FromAgent: "sender",
|
||||
ToAgent: "reader",
|
||||
Body: fmt.Sprintf("combined msg %d", i),
|
||||
Priority: 5 + (i % 3),
|
||||
Status: StatusPending,
|
||||
}
|
||||
if err := store.InsertMessage(ctx, msg); err != nil {
|
||||
t.Fatalf("InsertMessage: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("filters + offset + limit", func(t *testing.T) {
|
||||
// Get all with min_priority=6 first to know expected count
|
||||
all, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
MinPriority: 6,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
|
||||
// Now paginate through
|
||||
page1, err := store.GetInboxMessages(ctx, "reader", ReadOptions{
|
||||
MinPriority: 6,
|
||||
Limit: 2,
|
||||
Offset: 0,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetInboxMessages: %v", err)
|
||||
}
|
||||
|
||||
count, err := store.CountInboxMessages(ctx, "reader", ReadOptions{
|
||||
MinPriority: 6,
|
||||
IncludeRead: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CountInboxMessages: %v", err)
|
||||
}
|
||||
|
||||
if count != len(all) {
|
||||
t.Errorf("count = %d, want %d", count, len(all))
|
||||
}
|
||||
|
||||
if len(page1) > 2 {
|
||||
t.Errorf("page1 got %d messages, want at most 2", len(page1))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
@@ -57,6 +57,14 @@ type DeadLetter struct {
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
// PaginatedMessages holds a page of messages with total count.
|
||||
type PaginatedMessages struct {
|
||||
Messages []*Message `json:"messages"`
|
||||
Total int `json:"total"`
|
||||
Offset int `json:"offset"`
|
||||
Limit int `json:"limit"`
|
||||
}
|
||||
|
||||
// InboxState tracks per-agent, per-conversation read position.
|
||||
type InboxState struct {
|
||||
AgentName string `json:"agent_name"`
|
||||
@@ -64,3 +72,10 @@ type InboxState struct {
|
||||
LastReadMessageID int64 `json:"last_read_message_id"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
// DMUnreadCount holds the unread DM count for a specific peer agent.
|
||||
type DMUnreadCount struct {
|
||||
Agent string `json:"agent"`
|
||||
UnreadCount int `json:"unread_count"`
|
||||
LastMessageID int64 `json:"last_message_id"`
|
||||
}
|
||||
|
||||
@@ -0,0 +1,279 @@
|
||||
package push
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ecdsa"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"math/big"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
|
||||
webpush "github.com/SherClockHolmes/webpush-go"
|
||||
)
|
||||
|
||||
// Service manages Web Push notifications and VAPID key lifecycle.
|
||||
type Service struct {
|
||||
store Store
|
||||
vapidKeys *VAPIDKeys
|
||||
dataDir string
|
||||
logger *slog.Logger
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
// VAPIDKeys holds the VAPID key pair for Web Push authentication.
|
||||
type VAPIDKeys struct {
|
||||
PublicKey string `json:"public_key"`
|
||||
PrivateKey string `json:"private_key"`
|
||||
}
|
||||
|
||||
// Notification represents a push notification payload.
|
||||
type Notification struct {
|
||||
Title string `json:"title"`
|
||||
Body string `json:"body"`
|
||||
Tag string `json:"tag,omitempty"`
|
||||
URL string `json:"url,omitempty"`
|
||||
}
|
||||
|
||||
// NewService creates a new push notification service.
|
||||
// It loads or generates VAPID keys from the data directory.
|
||||
func NewService(store Store, dataDir string, logger *slog.Logger) (*Service, error) {
|
||||
s := &Service{
|
||||
store: store,
|
||||
dataDir: dataDir,
|
||||
logger: logger.With("component", "push"),
|
||||
}
|
||||
|
||||
keys, err := s.loadOrGenerateVAPIDKeys()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("load or generate VAPID keys: %w", err)
|
||||
}
|
||||
s.vapidKeys = keys
|
||||
|
||||
s.logger.Info("push notification service initialized",
|
||||
"vapid_public_key", keys.PublicKey[:16]+"...",
|
||||
)
|
||||
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// GetVAPIDPublicKey returns the VAPID public key for client subscription.
|
||||
func (s *Service) GetVAPIDPublicKey() string {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.vapidKeys.PublicKey
|
||||
}
|
||||
|
||||
// Subscribe registers a push subscription for a user.
|
||||
func (s *Service) Subscribe(ctx context.Context, userID int64, endpoint, keyP256dh, keyAuth, userAgent string) error {
|
||||
return s.store.Subscribe(ctx, userID, endpoint, keyP256dh, keyAuth, userAgent)
|
||||
}
|
||||
|
||||
// Unsubscribe removes a push subscription by endpoint, scoped to user.
|
||||
func (s *Service) Unsubscribe(ctx context.Context, userID int64, endpoint string) error {
|
||||
return s.store.Unsubscribe(ctx, userID, endpoint)
|
||||
}
|
||||
|
||||
// SendToUser sends a push notification to all subscriptions for a user.
|
||||
// It automatically removes subscriptions that return 410 Gone (unsubscribed).
|
||||
func (s *Service) SendToUser(ctx context.Context, userID int64, notification Notification) error {
|
||||
subs, err := s.store.GetSubscriptions(ctx, userID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("get subscriptions: %w", err)
|
||||
}
|
||||
|
||||
if len(subs) == 0 {
|
||||
s.logger.Debug("no push subscriptions for user", "user_id", userID)
|
||||
return nil
|
||||
}
|
||||
|
||||
payload, err := json.Marshal(notification)
|
||||
if err != nil {
|
||||
return fmt.Errorf("marshal notification: %w", err)
|
||||
}
|
||||
|
||||
s.mu.RLock()
|
||||
vapidPrivate := s.vapidKeys.PrivateKey
|
||||
vapidPublic := s.vapidKeys.PublicKey
|
||||
s.mu.RUnlock()
|
||||
|
||||
var sendErrors []error
|
||||
for _, sub := range subs {
|
||||
wpSub := &webpush.Subscription{
|
||||
Endpoint: sub.Endpoint,
|
||||
Keys: webpush.Keys{
|
||||
P256dh: sub.KeyP256dh,
|
||||
Auth: sub.KeyAuth,
|
||||
},
|
||||
}
|
||||
|
||||
resp, err := webpush.SendNotification(payload, wpSub, &webpush.Options{
|
||||
VAPIDPrivateKey: vapidPrivate,
|
||||
VAPIDPublicKey: vapidPublic,
|
||||
Subscriber: "mailto:noreply@synapbus.local",
|
||||
TTL: 86400, // 24 hours
|
||||
})
|
||||
if err != nil {
|
||||
s.logger.Warn("push notification send failed",
|
||||
"user_id", userID,
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
"error", err,
|
||||
)
|
||||
sendErrors = append(sendErrors, err)
|
||||
continue
|
||||
}
|
||||
resp.Body.Close()
|
||||
|
||||
// Remove stale subscriptions
|
||||
if resp.StatusCode == http.StatusGone {
|
||||
s.logger.Info("removing stale push subscription",
|
||||
"user_id", userID,
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
)
|
||||
if delErr := s.store.DeleteSubscription(ctx, sub.Endpoint); delErr != nil {
|
||||
s.logger.Warn("failed to delete stale subscription",
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
"error", delErr,
|
||||
)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if resp.StatusCode >= 400 {
|
||||
s.logger.Warn("push notification rejected",
|
||||
"user_id", userID,
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
"status", resp.StatusCode,
|
||||
)
|
||||
sendErrors = append(sendErrors, fmt.Errorf("push endpoint returned %d", resp.StatusCode))
|
||||
|
||||
// Also remove subscriptions that return 404 (endpoint no longer valid)
|
||||
if resp.StatusCode == http.StatusNotFound {
|
||||
if delErr := s.store.DeleteSubscription(ctx, sub.Endpoint); delErr != nil {
|
||||
s.logger.Warn("failed to delete invalid subscription",
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
"error", delErr,
|
||||
)
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
s.logger.Debug("push notification sent",
|
||||
"user_id", userID,
|
||||
"endpoint", truncateEndpoint(sub.Endpoint),
|
||||
"status", resp.StatusCode,
|
||||
)
|
||||
}
|
||||
|
||||
if len(sendErrors) > 0 {
|
||||
return fmt.Errorf("failed to send to %d/%d subscriptions", len(sendErrors), len(subs))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// vapidKeysPath returns the file path for the VAPID keys JSON file.
|
||||
func (s *Service) vapidKeysPath() string {
|
||||
return filepath.Join(s.dataDir, "vapid_keys.json")
|
||||
}
|
||||
|
||||
// loadOrGenerateVAPIDKeys loads existing VAPID keys from disk or generates new ones.
|
||||
func (s *Service) loadOrGenerateVAPIDKeys() (*VAPIDKeys, error) {
|
||||
keysPath := s.vapidKeysPath()
|
||||
|
||||
// Try to load existing keys
|
||||
data, err := os.ReadFile(keysPath)
|
||||
if err == nil {
|
||||
var keys VAPIDKeys
|
||||
if err := json.Unmarshal(data, &keys); err == nil && keys.PublicKey != "" && keys.PrivateKey != "" {
|
||||
s.logger.Info("loaded existing VAPID keys", "path", keysPath)
|
||||
return &keys, nil
|
||||
}
|
||||
s.logger.Warn("invalid VAPID keys file, regenerating", "path", keysPath)
|
||||
}
|
||||
|
||||
// Generate new VAPID keys
|
||||
keys, err := generateVAPIDKeys()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("generate VAPID keys: %w", err)
|
||||
}
|
||||
|
||||
// Ensure data directory exists
|
||||
if err := os.MkdirAll(s.dataDir, 0o755); err != nil {
|
||||
return nil, fmt.Errorf("create data directory: %w", err)
|
||||
}
|
||||
|
||||
// Save to disk
|
||||
data, err = json.MarshalIndent(keys, "", " ")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal VAPID keys: %w", err)
|
||||
}
|
||||
|
||||
if err := os.WriteFile(keysPath, data, 0o600); err != nil {
|
||||
return nil, fmt.Errorf("write VAPID keys: %w", err)
|
||||
}
|
||||
|
||||
s.logger.Info("generated new VAPID keys", "path", keysPath)
|
||||
return keys, nil
|
||||
}
|
||||
|
||||
// generateVAPIDKeys creates a new ECDSA P-256 key pair and encodes them
|
||||
// as uncompressed (public) and raw (private) base64url strings for VAPID.
|
||||
func generateVAPIDKeys() (*VAPIDKeys, error) {
|
||||
privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("generate ECDSA key: %w", err)
|
||||
}
|
||||
|
||||
// Encode public key as uncompressed point (0x04 || x || y)
|
||||
pubBytes := elliptic.Marshal(elliptic.P256(), privateKey.PublicKey.X, privateKey.PublicKey.Y)
|
||||
publicKeyB64 := base64.RawURLEncoding.EncodeToString(pubBytes)
|
||||
|
||||
// Encode private key as raw big-endian bytes (32 bytes, zero-padded)
|
||||
privBytes := privateKey.D.Bytes()
|
||||
// Pad to 32 bytes if needed
|
||||
padded := make([]byte, 32)
|
||||
copy(padded[32-len(privBytes):], privBytes)
|
||||
privateKeyB64 := base64.RawURLEncoding.EncodeToString(padded)
|
||||
|
||||
return &VAPIDKeys{
|
||||
PublicKey: publicKeyB64,
|
||||
PrivateKey: privateKeyB64,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// ParseVAPIDPrivateKey decodes a base64url-encoded VAPID private key
|
||||
// into an *ecdsa.PrivateKey. Useful for testing.
|
||||
func ParseVAPIDPrivateKey(b64 string) (*ecdsa.PrivateKey, error) {
|
||||
raw, err := base64.RawURLEncoding.DecodeString(b64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("decode private key: %w", err)
|
||||
}
|
||||
|
||||
d := new(big.Int).SetBytes(raw)
|
||||
curve := elliptic.P256()
|
||||
x, y := curve.ScalarBaseMult(raw)
|
||||
|
||||
return &ecdsa.PrivateKey{
|
||||
PublicKey: ecdsa.PublicKey{
|
||||
Curve: curve,
|
||||
X: x,
|
||||
Y: y,
|
||||
},
|
||||
D: d,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// truncateEndpoint returns a truncated version of the endpoint URL for logging.
|
||||
func truncateEndpoint(endpoint string) string {
|
||||
if len(endpoint) <= 40 {
|
||||
return endpoint
|
||||
}
|
||||
return endpoint[:37] + "..."
|
||||
}
|
||||
@@ -0,0 +1,340 @@
|
||||
package push
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ecdsa"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// mockStore implements Store for testing without a database.
|
||||
type mockStore struct {
|
||||
subscriptions map[int64][]Subscription
|
||||
deleted []string
|
||||
}
|
||||
|
||||
func newMockStore() *mockStore {
|
||||
return &mockStore{
|
||||
subscriptions: make(map[int64][]Subscription),
|
||||
}
|
||||
}
|
||||
|
||||
func (m *mockStore) Subscribe(_ context.Context, userID int64, endpoint, keyP256dh, keyAuth, userAgent string) error {
|
||||
// Upsert: remove existing endpoint first
|
||||
subs := m.subscriptions[userID]
|
||||
for i, s := range subs {
|
||||
if s.Endpoint == endpoint {
|
||||
subs = append(subs[:i], subs[i+1:]...)
|
||||
break
|
||||
}
|
||||
}
|
||||
m.subscriptions[userID] = append(subs, Subscription{
|
||||
UserID: userID,
|
||||
Endpoint: endpoint,
|
||||
KeyP256dh: keyP256dh,
|
||||
KeyAuth: keyAuth,
|
||||
UserAgent: userAgent,
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *mockStore) Unsubscribe(_ context.Context, userID int64, endpoint string) error {
|
||||
subs := m.subscriptions[userID]
|
||||
for i, s := range subs {
|
||||
if s.Endpoint == endpoint {
|
||||
m.subscriptions[userID] = append(subs[:i], subs[i+1:]...)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *mockStore) GetSubscriptions(_ context.Context, userID int64) ([]Subscription, error) {
|
||||
return m.subscriptions[userID], nil
|
||||
}
|
||||
|
||||
func (m *mockStore) DeleteSubscription(_ context.Context, endpoint string) error {
|
||||
m.deleted = append(m.deleted, endpoint)
|
||||
// Find and remove from any user's subscriptions
|
||||
for uid, subs := range m.subscriptions {
|
||||
for i, s := range subs {
|
||||
if s.Endpoint == endpoint {
|
||||
m.subscriptions[uid] = append(subs[:i], subs[i+1:]...)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func TestVAPIDKeyGeneration(t *testing.T) {
|
||||
keys, err := generateVAPIDKeys()
|
||||
if err != nil {
|
||||
t.Fatalf("generateVAPIDKeys: %v", err)
|
||||
}
|
||||
|
||||
if keys.PublicKey == "" {
|
||||
t.Error("public key is empty")
|
||||
}
|
||||
if keys.PrivateKey == "" {
|
||||
t.Error("private key is empty")
|
||||
}
|
||||
|
||||
// Public key should be 65 bytes (uncompressed point) base64url encoded
|
||||
// 65 bytes -> ceil(65*4/3) = 87 chars without padding
|
||||
if len(keys.PublicKey) < 80 {
|
||||
t.Errorf("public key too short: %d chars", len(keys.PublicKey))
|
||||
}
|
||||
|
||||
// Private key should be 32 bytes base64url encoded
|
||||
// 32 bytes -> ceil(32*4/3) = 43 chars without padding
|
||||
if len(keys.PrivateKey) < 40 {
|
||||
t.Errorf("private key too short: %d chars", len(keys.PrivateKey))
|
||||
}
|
||||
|
||||
// Should be parseable back into an ECDSA key
|
||||
privKey, err := ParseVAPIDPrivateKey(keys.PrivateKey)
|
||||
if err != nil {
|
||||
t.Fatalf("ParseVAPIDPrivateKey: %v", err)
|
||||
}
|
||||
if privKey.Curve == nil {
|
||||
t.Error("parsed key has nil curve")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVAPIDKeyPersistence(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
// First service creation should generate keys
|
||||
svc1, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
key1 := svc1.GetVAPIDPublicKey()
|
||||
if key1 == "" {
|
||||
t.Fatal("VAPID public key is empty")
|
||||
}
|
||||
|
||||
// Verify file was written
|
||||
keysPath := filepath.Join(tmpDir, "vapid_keys.json")
|
||||
data, err := os.ReadFile(keysPath)
|
||||
if err != nil {
|
||||
t.Fatalf("read VAPID keys file: %v", err)
|
||||
}
|
||||
|
||||
var savedKeys VAPIDKeys
|
||||
if err := json.Unmarshal(data, &savedKeys); err != nil {
|
||||
t.Fatalf("unmarshal saved keys: %v", err)
|
||||
}
|
||||
if savedKeys.PublicKey != key1 {
|
||||
t.Errorf("saved public key = %q, service key = %q", savedKeys.PublicKey, key1)
|
||||
}
|
||||
|
||||
// Second service creation should load the same keys
|
||||
svc2, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService (second): %v", err)
|
||||
}
|
||||
key2 := svc2.GetVAPIDPublicKey()
|
||||
if key2 != key1 {
|
||||
t.Errorf("second service has different key: %q vs %q", key2, key1)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVAPIDKeyFilePermissions(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
_, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
|
||||
keysPath := filepath.Join(tmpDir, "vapid_keys.json")
|
||||
info, err := os.Stat(keysPath)
|
||||
if err != nil {
|
||||
t.Fatalf("stat VAPID keys file: %v", err)
|
||||
}
|
||||
|
||||
perm := info.Mode().Perm()
|
||||
if perm&0o077 != 0 {
|
||||
t.Errorf("VAPID keys file has overly permissive mode: %o (want 0600)", perm)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSendToUser_NoSubscriptions(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
svc, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
|
||||
// Sending to a user with no subscriptions should not error
|
||||
err = svc.SendToUser(context.Background(), 999, Notification{
|
||||
Title: "Test",
|
||||
Body: "Test body",
|
||||
})
|
||||
if err != nil {
|
||||
t.Errorf("SendToUser with no subs: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// generateTestSubscriptionKeys creates a valid ECDSA P-256 key pair
|
||||
// encoded as base64url for use as Web Push subscription keys in tests.
|
||||
func generateTestSubscriptionKeys(t *testing.T) (p256dh, auth string) {
|
||||
t.Helper()
|
||||
privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
t.Fatalf("generate test key: %v", err)
|
||||
}
|
||||
pubBytes := elliptic.Marshal(elliptic.P256(), privKey.PublicKey.X, privKey.PublicKey.Y)
|
||||
p256dh = base64.RawURLEncoding.EncodeToString(pubBytes)
|
||||
|
||||
authBytes := make([]byte, 16)
|
||||
rand.Read(authBytes)
|
||||
auth = base64.RawURLEncoding.EncodeToString(authBytes)
|
||||
return
|
||||
}
|
||||
|
||||
func TestSendToUser_GoneSubscription(t *testing.T) {
|
||||
// Set up a fake push endpoint that returns 410 Gone
|
||||
var requestCount atomic.Int32
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
requestCount.Add(1)
|
||||
w.WriteHeader(http.StatusGone)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
svc, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
|
||||
p256dh, authKey := generateTestSubscriptionKeys(t)
|
||||
store.Subscribe(context.Background(), 1, server.URL+"/push", p256dh, authKey, "TestAgent")
|
||||
|
||||
// Send notification — should succeed but remove the stale subscription
|
||||
_ = svc.SendToUser(context.Background(), 1, Notification{
|
||||
Title: "Test",
|
||||
Body: "Test body",
|
||||
})
|
||||
|
||||
if requestCount.Load() == 0 {
|
||||
t.Fatal("expected at least one request to push endpoint")
|
||||
}
|
||||
|
||||
// The stale subscription should have been deleted
|
||||
if len(store.deleted) != 1 {
|
||||
t.Errorf("expected 1 deleted subscription, got %d", len(store.deleted))
|
||||
}
|
||||
if len(store.deleted) > 0 && store.deleted[0] != server.URL+"/push" {
|
||||
t.Errorf("deleted wrong endpoint: %q", store.deleted[0])
|
||||
}
|
||||
}
|
||||
|
||||
func TestSendToUser_NotFoundSubscription(t *testing.T) {
|
||||
// Set up a fake push endpoint that returns 404
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusNotFound)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
svc, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
|
||||
p256dh, authKey := generateTestSubscriptionKeys(t)
|
||||
store.Subscribe(context.Background(), 1, server.URL+"/push", p256dh, authKey, "TestAgent")
|
||||
|
||||
_ = svc.SendToUser(context.Background(), 1, Notification{
|
||||
Title: "Test",
|
||||
Body: "Test body",
|
||||
})
|
||||
|
||||
// 404 should also trigger deletion
|
||||
if len(store.deleted) != 1 {
|
||||
t.Errorf("expected 1 deleted subscription, got %d", len(store.deleted))
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceSubscribeUnsubscribe(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
logger := slog.Default()
|
||||
store := newMockStore()
|
||||
|
||||
svc, err := NewService(store, tmpDir, logger)
|
||||
if err != nil {
|
||||
t.Fatalf("NewService: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
// Subscribe
|
||||
err = svc.Subscribe(ctx, 1, "https://push.example.com/test", "p256dh", "auth", "Agent")
|
||||
if err != nil {
|
||||
t.Fatalf("Subscribe: %v", err)
|
||||
}
|
||||
|
||||
subs := store.subscriptions[1]
|
||||
if len(subs) != 1 {
|
||||
t.Fatalf("got %d subscriptions, want 1", len(subs))
|
||||
}
|
||||
|
||||
// Unsubscribe
|
||||
err = svc.Unsubscribe(ctx, 1, "https://push.example.com/test")
|
||||
if err != nil {
|
||||
t.Fatalf("Unsubscribe: %v", err)
|
||||
}
|
||||
|
||||
subs = store.subscriptions[1]
|
||||
if len(subs) != 0 {
|
||||
t.Errorf("got %d subscriptions after unsubscribe, want 0", len(subs))
|
||||
}
|
||||
}
|
||||
|
||||
func TestTruncateEndpoint(t *testing.T) {
|
||||
short := "https://short.url"
|
||||
long := "https://push.services.mozilla.com/wpush/v2/very-long-subscription-id-that-goes-on-and-on"
|
||||
|
||||
got := truncateEndpoint(short)
|
||||
if got != short {
|
||||
t.Errorf("truncateEndpoint(short) = %q, want %q", got, short)
|
||||
}
|
||||
|
||||
got = truncateEndpoint(long)
|
||||
if len(got) != 40 {
|
||||
t.Errorf("truncateEndpoint(long) length = %d, want 40", len(got))
|
||||
}
|
||||
if got[len(got)-3:] != "..." {
|
||||
t.Errorf("truncateEndpoint(long) should end with '...', got %q", got)
|
||||
}
|
||||
|
||||
got = truncateEndpoint("")
|
||||
if got != "" {
|
||||
t.Errorf("truncateEndpoint('') = %q, want ''", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
// Package push provides Web Push notification support for SynapBus.
|
||||
package push
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
)
|
||||
|
||||
// Store defines the persistence interface for push subscriptions.
|
||||
type Store interface {
|
||||
// Subscribe registers a push subscription for a user.
|
||||
// If the endpoint already exists, it updates the keys and user agent.
|
||||
Subscribe(ctx context.Context, userID int64, endpoint, keyP256dh, keyAuth, userAgent string) error
|
||||
|
||||
// Unsubscribe removes a push subscription by endpoint, scoped to user.
|
||||
Unsubscribe(ctx context.Context, userID int64, endpoint string) error
|
||||
|
||||
// GetSubscriptions returns all push subscriptions for a user.
|
||||
GetSubscriptions(ctx context.Context, userID int64) ([]Subscription, error)
|
||||
|
||||
// DeleteSubscription removes a push subscription by endpoint.
|
||||
// This is used to clean up stale subscriptions (e.g., 410 Gone responses).
|
||||
DeleteSubscription(ctx context.Context, endpoint string) error
|
||||
}
|
||||
|
||||
// Subscription represents a Web Push subscription stored in the database.
|
||||
type Subscription struct {
|
||||
ID int64
|
||||
UserID int64
|
||||
Endpoint string
|
||||
KeyP256dh string
|
||||
KeyAuth string
|
||||
UserAgent string
|
||||
CreatedAt string
|
||||
}
|
||||
|
||||
// SQLiteStore implements Store using SQLite.
|
||||
type SQLiteStore struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
// NewSQLiteStore creates a new SQLite-backed push subscription store.
|
||||
func NewSQLiteStore(db *sql.DB) *SQLiteStore {
|
||||
return &SQLiteStore{db: db}
|
||||
}
|
||||
|
||||
// Subscribe registers or updates a push subscription for a user.
|
||||
func (s *SQLiteStore) Subscribe(ctx context.Context, userID int64, endpoint, keyP256dh, keyAuth, userAgent string) error {
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`INSERT INTO push_subscriptions (user_id, endpoint, key_p256dh, key_auth, user_agent)
|
||||
VALUES (?, ?, ?, ?, ?)
|
||||
ON CONFLICT(endpoint) DO UPDATE SET
|
||||
key_p256dh = excluded.key_p256dh,
|
||||
key_auth = excluded.key_auth,
|
||||
user_agent = excluded.user_agent,
|
||||
user_id = excluded.user_id`,
|
||||
userID, endpoint, keyP256dh, keyAuth, userAgent,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
// Unsubscribe removes a push subscription by endpoint, scoped to the owning user.
|
||||
func (s *SQLiteStore) Unsubscribe(ctx context.Context, userID int64, endpoint string) error {
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`DELETE FROM push_subscriptions WHERE user_id = ? AND endpoint = ?`,
|
||||
userID, endpoint,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetSubscriptions returns all push subscriptions for a user.
|
||||
func (s *SQLiteStore) GetSubscriptions(ctx context.Context, userID int64) ([]Subscription, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT id, user_id, endpoint, key_p256dh, key_auth, user_agent, created_at
|
||||
FROM push_subscriptions
|
||||
WHERE user_id = ?
|
||||
ORDER BY created_at DESC`,
|
||||
userID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var subs []Subscription
|
||||
for rows.Next() {
|
||||
var sub Subscription
|
||||
if err := rows.Scan(&sub.ID, &sub.UserID, &sub.Endpoint, &sub.KeyP256dh, &sub.KeyAuth, &sub.UserAgent, &sub.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
subs = append(subs, sub)
|
||||
}
|
||||
return subs, rows.Err()
|
||||
}
|
||||
|
||||
// DeleteSubscription removes a push subscription by endpoint (any user).
|
||||
// Used for stale subscription cleanup (e.g., 410 Gone responses).
|
||||
func (s *SQLiteStore) DeleteSubscription(ctx context.Context, endpoint string) error {
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`DELETE FROM push_subscriptions WHERE endpoint = ?`,
|
||||
endpoint,
|
||||
)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package push
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"github.com/synapbus/synapbus/internal/storage"
|
||||
)
|
||||
|
||||
func newTestDB(t *testing.T) *sql.DB {
|
||||
t.Helper()
|
||||
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", t.Name())
|
||||
db, err := sql.Open("sqlite", dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("open database: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { db.Close() })
|
||||
|
||||
if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
|
||||
t.Fatalf("enable foreign keys: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
if err := storage.RunMigrations(ctx, db); err != nil {
|
||||
t.Fatalf("run migrations: %v", err)
|
||||
}
|
||||
|
||||
// Seed a test user
|
||||
db.Exec(`INSERT OR IGNORE INTO users (id, username, password_hash, display_name) VALUES (1, 'testuser', 'hash', 'Test User')`)
|
||||
db.Exec(`INSERT OR IGNORE INTO users (id, username, password_hash, display_name) VALUES (2, 'otheruser', 'hash', 'Other User')`)
|
||||
|
||||
return db
|
||||
}
|
||||
|
||||
func TestSQLiteStore_Subscribe(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
err := store.Subscribe(ctx, 1, "https://push.example.com/sub1", "p256dh-key-1", "auth-key-1", "TestAgent/1.0")
|
||||
if err != nil {
|
||||
t.Fatalf("Subscribe: %v", err)
|
||||
}
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if len(subs) != 1 {
|
||||
t.Fatalf("got %d subscriptions, want 1", len(subs))
|
||||
}
|
||||
|
||||
sub := subs[0]
|
||||
if sub.Endpoint != "https://push.example.com/sub1" {
|
||||
t.Errorf("endpoint = %q, want %q", sub.Endpoint, "https://push.example.com/sub1")
|
||||
}
|
||||
if sub.KeyP256dh != "p256dh-key-1" {
|
||||
t.Errorf("key_p256dh = %q, want %q", sub.KeyP256dh, "p256dh-key-1")
|
||||
}
|
||||
if sub.KeyAuth != "auth-key-1" {
|
||||
t.Errorf("key_auth = %q, want %q", sub.KeyAuth, "auth-key-1")
|
||||
}
|
||||
if sub.UserAgent != "TestAgent/1.0" {
|
||||
t.Errorf("user_agent = %q, want %q", sub.UserAgent, "TestAgent/1.0")
|
||||
}
|
||||
if sub.UserID != 1 {
|
||||
t.Errorf("user_id = %d, want 1", sub.UserID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_SubscribeUpsert(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
// First subscription
|
||||
err := store.Subscribe(ctx, 1, "https://push.example.com/sub1", "old-p256dh", "old-auth", "OldAgent")
|
||||
if err != nil {
|
||||
t.Fatalf("Subscribe: %v", err)
|
||||
}
|
||||
|
||||
// Update same endpoint with new keys
|
||||
err = store.Subscribe(ctx, 1, "https://push.example.com/sub1", "new-p256dh", "new-auth", "NewAgent")
|
||||
if err != nil {
|
||||
t.Fatalf("Subscribe upsert: %v", err)
|
||||
}
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if len(subs) != 1 {
|
||||
t.Fatalf("got %d subscriptions, want 1 (should upsert)", len(subs))
|
||||
}
|
||||
if subs[0].KeyP256dh != "new-p256dh" {
|
||||
t.Errorf("key_p256dh = %q, want %q", subs[0].KeyP256dh, "new-p256dh")
|
||||
}
|
||||
if subs[0].KeyAuth != "new-auth" {
|
||||
t.Errorf("key_auth = %q, want %q", subs[0].KeyAuth, "new-auth")
|
||||
}
|
||||
if subs[0].UserAgent != "NewAgent" {
|
||||
t.Errorf("user_agent = %q, want %q", subs[0].UserAgent, "NewAgent")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_MultipleSubscriptions(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
// Register multiple subscriptions for same user
|
||||
for i := 0; i < 3; i++ {
|
||||
endpoint := fmt.Sprintf("https://push.example.com/sub%d", i)
|
||||
err := store.Subscribe(ctx, 1, endpoint, fmt.Sprintf("p256dh-%d", i), fmt.Sprintf("auth-%d", i), "Agent")
|
||||
if err != nil {
|
||||
t.Fatalf("Subscribe(%d): %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if len(subs) != 3 {
|
||||
t.Errorf("got %d subscriptions, want 3", len(subs))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_Unsubscribe(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
store.Subscribe(ctx, 1, "https://push.example.com/sub1", "p256dh", "auth", "Agent")
|
||||
store.Subscribe(ctx, 1, "https://push.example.com/sub2", "p256dh2", "auth2", "Agent")
|
||||
|
||||
err := store.Unsubscribe(ctx, 1, "https://push.example.com/sub1")
|
||||
if err != nil {
|
||||
t.Fatalf("Unsubscribe: %v", err)
|
||||
}
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if len(subs) != 1 {
|
||||
t.Fatalf("got %d subscriptions, want 1", len(subs))
|
||||
}
|
||||
if subs[0].Endpoint != "https://push.example.com/sub2" {
|
||||
t.Errorf("remaining endpoint = %q, want sub2", subs[0].Endpoint)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_DeleteSubscription(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
store.Subscribe(ctx, 1, "https://push.example.com/sub1", "p256dh", "auth", "Agent")
|
||||
|
||||
err := store.DeleteSubscription(ctx, "https://push.example.com/sub1")
|
||||
if err != nil {
|
||||
t.Fatalf("DeleteSubscription: %v", err)
|
||||
}
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if len(subs) != 0 {
|
||||
t.Errorf("got %d subscriptions, want 0", len(subs))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_UserIsolation(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
store.Subscribe(ctx, 1, "https://push.example.com/user1-sub", "p256dh1", "auth1", "Agent")
|
||||
store.Subscribe(ctx, 2, "https://push.example.com/user2-sub", "p256dh2", "auth2", "Agent")
|
||||
|
||||
subs1, err := store.GetSubscriptions(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions(1): %v", err)
|
||||
}
|
||||
if len(subs1) != 1 {
|
||||
t.Errorf("user 1: got %d subscriptions, want 1", len(subs1))
|
||||
}
|
||||
|
||||
subs2, err := store.GetSubscriptions(ctx, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions(2): %v", err)
|
||||
}
|
||||
if len(subs2) != 1 {
|
||||
t.Errorf("user 2: got %d subscriptions, want 1", len(subs2))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_GetSubscriptionsEmpty(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
subs, err := store.GetSubscriptions(ctx, 999)
|
||||
if err != nil {
|
||||
t.Fatalf("GetSubscriptions: %v", err)
|
||||
}
|
||||
if subs != nil {
|
||||
t.Errorf("got %v, want nil for empty result", subs)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteStore_UnsubscribeNonexistent(t *testing.T) {
|
||||
db := newTestDB(t)
|
||||
store := NewSQLiteStore(db)
|
||||
ctx := context.Background()
|
||||
|
||||
// Should not error when deleting non-existent endpoint
|
||||
err := store.Unsubscribe(ctx, 1, "https://push.example.com/nonexistent")
|
||||
if err != nil {
|
||||
t.Fatalf("Unsubscribe non-existent: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -207,11 +207,12 @@ func (s *Service) fulltextSearch(ctx context.Context, agentName string, opts Sea
|
||||
msgOpts.ChannelID = opts.ChannelID
|
||||
}
|
||||
|
||||
messages, err := s.msgService.SearchMessages(ctx, agentName, opts.Query, msgOpts)
|
||||
paginated, err := s.msgService.SearchMessages(ctx, agentName, opts.Query, msgOpts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("fulltext search: %w", err)
|
||||
}
|
||||
|
||||
messages := paginated.Messages
|
||||
results := make([]*SearchResult, len(messages))
|
||||
for i, msg := range messages {
|
||||
results[i] = &SearchResult{
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
-- A2A inbound gateway: task tracking for external A2A agents sending tasks to SynapBus agents.
|
||||
CREATE TABLE IF NOT EXISTS a2a_tasks (
|
||||
id TEXT PRIMARY KEY,
|
||||
context_id TEXT NOT NULL,
|
||||
target_agent TEXT NOT NULL,
|
||||
source_agent TEXT DEFAULT '',
|
||||
conversation_id INTEGER,
|
||||
state TEXT NOT NULL DEFAULT 'SUBMITTED',
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_a2a_tasks_target ON a2a_tasks(target_agent);
|
||||
CREATE INDEX IF NOT EXISTS idx_a2a_tasks_state ON a2a_tasks(state);
|
||||
@@ -0,0 +1,23 @@
|
||||
-- External identity provider support (GitHub, Google, Azure AD)
|
||||
-- Links external IdP accounts to local SynapBus users
|
||||
|
||||
CREATE TABLE IF NOT EXISTS user_identities (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
provider TEXT NOT NULL,
|
||||
external_id TEXT NOT NULL,
|
||||
email TEXT,
|
||||
display_name TEXT,
|
||||
raw_claims TEXT NOT NULL DEFAULT '{}',
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
UNIQUE(provider, external_id)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_user_identities_user ON user_identities(user_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_user_identities_lookup ON user_identities(provider, external_id);
|
||||
|
||||
-- Add email column to users table for IdP linking
|
||||
ALTER TABLE users ADD COLUMN email TEXT;
|
||||
|
||||
INSERT INTO schema_migrations (version) VALUES (11);
|
||||
@@ -0,0 +1,12 @@
|
||||
-- Push notification subscriptions for Web Push API
|
||||
CREATE TABLE IF NOT EXISTS push_subscriptions (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
endpoint TEXT NOT NULL UNIQUE,
|
||||
key_p256dh TEXT NOT NULL,
|
||||
key_auth TEXT NOT NULL,
|
||||
user_agent TEXT DEFAULT '',
|
||||
created_at DATETIME NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_push_subscriptions_user_id ON push_subscriptions(user_id);
|
||||
Vendored
+15
-11
@@ -4,33 +4,37 @@
|
||||
<meta charset="utf-8" />
|
||||
<link rel="icon" href="/favicon.svg" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1" />
|
||||
<meta name="theme-color" content="#6366f1" />
|
||||
<link rel="manifest" href="/manifest.json" />
|
||||
<link rel="apple-touch-icon" href="/icons/icon-192.png" />
|
||||
<title>SynapBus</title>
|
||||
<link rel="preconnect" href="https://fonts.googleapis.com">
|
||||
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
|
||||
<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&family=Instrument+Sans:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
|
||||
<link href="/_app/immutable/entry/start.B4zIRc6l.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/k7nCSttu.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/DBeLgT1-.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/SAcaBy3_.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/DL-Ee-iM.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/BCvik_Lu.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/BdrVqzRy.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/entry/app.UyBC-CXX.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/entry/start.BuSotqBe.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/CoA7yCjK.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/BjgrqnN-.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/CAWWRzNH.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/B-GqcZrE.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/DpGxxGDS.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/3PInzq4O.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/chunks/qakGnb92.js" rel="modulepreload">
|
||||
<link href="/_app/immutable/entry/app.B5srta30.js" rel="modulepreload">
|
||||
|
||||
</head>
|
||||
<body data-sveltekit-preload-data="hover">
|
||||
<div style="display: contents">
|
||||
<script>
|
||||
{
|
||||
__sveltekit_ymf88 = {
|
||||
__sveltekit_1blyclv = {
|
||||
base: ""
|
||||
};
|
||||
|
||||
const element = document.currentScript.parentElement;
|
||||
|
||||
Promise.all([
|
||||
import("/_app/immutable/entry/start.B4zIRc6l.js"),
|
||||
import("/_app/immutable/entry/app.UyBC-CXX.js")
|
||||
import("/_app/immutable/entry/start.BuSotqBe.js"),
|
||||
import("/_app/immutable/entry/app.B5srta30.js")
|
||||
]).then(([kit, app]) => {
|
||||
kit.start(app, element);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
-- A2A inbound gateway: task tracking for external A2A agents sending tasks to SynapBus agents.
|
||||
CREATE TABLE IF NOT EXISTS a2a_tasks (
|
||||
id TEXT PRIMARY KEY,
|
||||
context_id TEXT NOT NULL,
|
||||
target_agent TEXT NOT NULL,
|
||||
source_agent TEXT DEFAULT '',
|
||||
conversation_id INTEGER,
|
||||
state TEXT NOT NULL DEFAULT 'SUBMITTED',
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_a2a_tasks_target ON a2a_tasks(target_agent);
|
||||
CREATE INDEX IF NOT EXISTS idx_a2a_tasks_state ON a2a_tasks(state);
|
||||
@@ -0,0 +1,23 @@
|
||||
-- External identity provider support (GitHub, Google, Azure AD)
|
||||
-- Links external IdP accounts to local SynapBus users
|
||||
|
||||
CREATE TABLE IF NOT EXISTS user_identities (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
provider TEXT NOT NULL,
|
||||
external_id TEXT NOT NULL,
|
||||
email TEXT,
|
||||
display_name TEXT,
|
||||
raw_claims TEXT NOT NULL DEFAULT '{}',
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
UNIQUE(provider, external_id)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_user_identities_user ON user_identities(user_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_user_identities_lookup ON user_identities(provider, external_id);
|
||||
|
||||
-- Add email column to users table for IdP linking
|
||||
ALTER TABLE users ADD COLUMN email TEXT;
|
||||
|
||||
INSERT INTO schema_migrations (version) VALUES (11);
|
||||
@@ -0,0 +1,12 @@
|
||||
-- Push notification subscriptions for Web Push API
|
||||
CREATE TABLE IF NOT EXISTS push_subscriptions (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
endpoint TEXT NOT NULL UNIQUE,
|
||||
key_p256dh TEXT NOT NULL,
|
||||
key_auth TEXT NOT NULL,
|
||||
user_agent TEXT DEFAULT '',
|
||||
created_at DATETIME NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_push_subscriptions_user_id ON push_subscriptions(user_id);
|
||||
@@ -0,0 +1,37 @@
|
||||
# Specification Quality Checklist: Hybrid MCP Tool Architecture
|
||||
|
||||
**Purpose**: Validate specification completeness and quality before proceeding to planning
|
||||
**Created**: 2026-03-15
|
||||
**Feature**: [spec.md](../spec.md)
|
||||
|
||||
## Content Quality
|
||||
|
||||
- [x] No implementation details (languages, frameworks, APIs)
|
||||
- [x] Focused on user value and business needs
|
||||
- [x] Written for non-technical stakeholders
|
||||
- [x] All mandatory sections completed
|
||||
|
||||
## Requirement Completeness
|
||||
|
||||
- [x] No [NEEDS CLARIFICATION] markers remain
|
||||
- [x] Requirements are testable and unambiguous
|
||||
- [x] Success criteria are measurable
|
||||
- [x] Success criteria are technology-agnostic (no implementation details)
|
||||
- [x] All acceptance scenarios are defined
|
||||
- [x] Edge cases are identified
|
||||
- [x] Scope is clearly bounded
|
||||
- [x] Dependencies and assumptions identified
|
||||
|
||||
## Feature Readiness
|
||||
|
||||
- [x] All functional requirements have clear acceptance criteria
|
||||
- [x] User scenarios cover primary flows
|
||||
- [x] Feature meets measurable outcomes defined in Success Criteria
|
||||
- [x] No implementation details leak into specification
|
||||
|
||||
## Notes
|
||||
|
||||
- Technology choices (goja, esbuild, BM25) are documented in Assumptions section only. Functional requirements are technology-agnostic (e.g., FR-032 says "transpile TypeScript" without naming a tool).
|
||||
- FR-035 lists specific APIs to block — this defines security boundaries, not implementation choice.
|
||||
- FR-022 references "BM25" — this is an algorithm specification, not a framework/library reference.
|
||||
- All items pass validation after spec review round 1 fixes (enumerated action catalog, memory limits, broadcast semantics, migration note, edge cases). Spec is ready for clarify or plan phase.
|
||||
@@ -0,0 +1,60 @@
|
||||
# Implementation Plan: Hybrid MCP Tool Architecture
|
||||
|
||||
## Phase 1 — Foundation (parallel, no cross-dependencies)
|
||||
|
||||
### Task A: JS/TS Runtime Engine (`internal/jsruntime/`)
|
||||
Port goja-based runtime from `../mcpproxy-go/internal/jsruntime/`. Simplified for SynapBus:
|
||||
- `runtime.go` — Execute(code, opts) with sandbox, timeout, call bridge
|
||||
- `pool.go` — Reusable runtime pool for concurrent executions
|
||||
- `typescript.go` — esbuild type-stripping transpilation
|
||||
- `*_test.go` — Table-driven tests for all components
|
||||
- ToolCaller interface: `Call(ctx, actionName, args) (any, error)`
|
||||
|
||||
### Task B: Action Registry + BM25 Search (`internal/actions/`)
|
||||
- `types.go` — Action struct (name, category, description, params, examples)
|
||||
- `registry.go` — Registry collecting all 23 action definitions with schemas
|
||||
- `search.go` — BM25 in-memory search over action docs
|
||||
- `*_test.go` — Tests for registry + search relevance
|
||||
- Each action definition maps to an existing service method
|
||||
|
||||
### Task C: Pagination + Advanced Filtering
|
||||
Modify existing service layer (no new packages):
|
||||
- `messaging/options.go` — Add Offset, After, Before fields to ReadOptions + SearchOptions
|
||||
- `messaging/store.go` — Update SQL queries for offset pagination + total count + date filtering
|
||||
- `messaging/service.go` — Return PaginatedResult{Items, Total, Offset, Limit}
|
||||
- `channels/store.go` — Pagination for GetChannelMessages, ListChannels
|
||||
- `channels/service.go` — Propagate pagination
|
||||
- `channels/task_store.go` — Pagination for ListTasks
|
||||
- `agents/` — Pagination for DiscoverAgents/ListAgents
|
||||
- Schema migration if indices needed
|
||||
- Tests for all modified queries
|
||||
|
||||
### Task D: CLI Subcommands
|
||||
Add to existing cobra CLI in `cmd/synapbus/admin.go`:
|
||||
- `synapbus webhook register|list|delete` — via admin Unix socket
|
||||
- `synapbus k8s register|list|delete` — via admin Unix socket
|
||||
- `synapbus attachments gc` — via admin Unix socket
|
||||
- Server-side: add admin socket handlers in `internal/admin/socket.go`
|
||||
- Wire webhook/k8s/attachment services into admin.Services struct
|
||||
- Tests
|
||||
|
||||
## Phase 2 — MCP Rewrite (depends on A + B + C)
|
||||
|
||||
### Task E: 4-Tool MCP Architecture (`internal/mcp/`)
|
||||
- Rewrite `server.go` constructor to accept jsruntime + action registry
|
||||
- New `tools_hybrid.go` — my_status, search, execute, send_message
|
||||
- Wire execute → jsruntime.Execute() with ToolCaller bridging to action registry
|
||||
- Wire search → actions.Registry.Search()
|
||||
- Wire send_message → merged DM + channel messaging
|
||||
- Remove old registrar files (tools.go handlers, channel_tools.go, swarm_tools.go, webhook_tools.go, tools_attachments.go)
|
||||
- Keep: server.go (modified), auth.go, connection.go, health.go
|
||||
- Update main.go constructor call
|
||||
- Comprehensive tests
|
||||
|
||||
## Phase 3 — Documentation (depends on all)
|
||||
|
||||
### Task F: Website Docs (`../synapbus-website/`)
|
||||
- Update MCP tools documentation (4 tools instead of 30)
|
||||
- Document execute code examples
|
||||
- Document CLI commands for admin operations
|
||||
- Update API reference
|
||||
@@ -0,0 +1,224 @@
|
||||
# Feature Specification: Hybrid MCP Tool Architecture
|
||||
|
||||
**Feature Branch**: `005-hybrid-mcp-tools`
|
||||
**Created**: 2026-03-15
|
||||
**Status**: Draft
|
||||
**Input**: Redesign SynapBus MCP tools from 30 individual tools to a hybrid 4-tool architecture with JS/TS code execution, BM25 tool discovery, pagination, advanced filtering, and CLI subcommands for admin operations.
|
||||
|
||||
## User Scenarios & Testing *(mandatory)*
|
||||
|
||||
### User Story 1 - Agent Sends a Message (Priority: P1)
|
||||
|
||||
An agent connects to SynapBus and sends a direct message to another agent or posts to a channel. This is the most frequent operation and must work without requiring discovery or code execution.
|
||||
|
||||
**Why this priority**: Messaging is the core function. Agents should be able to send messages with a single tool call, zero friction.
|
||||
|
||||
**Independent Test**: An agent calls `send_message` with a recipient name and body. The message is delivered. No other tools required.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** an authenticated agent, **When** it calls `send_message` with `to: "agent-bob"` and `body: "Hello"`, **Then** a direct message is delivered to agent-bob's inbox.
|
||||
2. **Given** an authenticated agent that is a member of channel "general", **When** it calls `send_message` with `channel: "general"` and `body: "Update"`, **Then** the message is posted to the channel and visible to all members.
|
||||
3. **Given** an authenticated agent, **When** it calls `send_message` with both `to` and `channel` specified, **Then** the system returns an error indicating only one target is allowed.
|
||||
4. **Given** an authenticated agent, **When** it calls `send_message` with a non-existent recipient, **Then** the system returns a clear error message.
|
||||
|
||||
---
|
||||
|
||||
### User Story 2 - Agent Discovers Status and Available Actions (Priority: P1)
|
||||
|
||||
An agent connects to SynapBus for the first time and calls `my_status` to understand its identity, pending messages, and what actions are available. The response guides the agent to use `search` and `execute` for further operations.
|
||||
|
||||
**Why this priority**: This is the onboarding entry point. Without it, agents don't know what's available.
|
||||
|
||||
**Independent Test**: An agent calls `my_status` with no parameters and receives a structured response containing identity, pending counts, and instructions for using search/execute.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** an authenticated agent with 3 pending messages and 2 channel mentions, **When** it calls `my_status`, **Then** it receives its identity, pending message count (3), mention count (2), channel memberships, and usage instructions for `search` and `execute`.
|
||||
2. **Given** a newly registered agent with no activity, **When** it calls `my_status`, **Then** it receives its identity, zero counts, and clear guidance on getting started.
|
||||
|
||||
---
|
||||
|
||||
### User Story 3 - Agent Discovers and Executes Any Action (Priority: P1)
|
||||
|
||||
An agent needs to perform an operation (e.g., read inbox, join a channel, post a task). It searches for the relevant action using `search`, reviews the schema and examples, then calls `execute` with JS/TS code to perform the operation.
|
||||
|
||||
**Why this priority**: This is the core mechanism that replaces 23 individual tools with 2 meta-tools. Without it, agents lose access to all non-direct functionality.
|
||||
|
||||
**Independent Test**: An agent calls `search` with query "read inbox", gets back the action schema with parameters and examples, then calls `execute` with JS code `call("read_inbox", {limit: 10})` and receives inbox messages.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** an authenticated agent, **When** it calls `search` with query `"join channel"`, **Then** it receives a list of matching actions with names, descriptions, parameter schemas, and usage examples ranked by relevance.
|
||||
2. **Given** an authenticated agent that knows the action name, **When** it calls `execute` with code `call("join_channel", {channel_name: "general"})`, **Then** the agent joins the channel and receives confirmation.
|
||||
3. **Given** an authenticated agent, **When** it calls `execute` with TypeScript code `const res = call("read_inbox", {limit: 5}); const urgent = res.messages.filter((m: any) => m.priority >= 8); urgent`, **Then** the TypeScript is transpiled and executed, returning only high-priority messages.
|
||||
4. **Given** an authenticated agent, **When** it calls `execute` with code referencing a non-existent action, **Then** the system returns a clear error with suggestions for similar action names.
|
||||
5. **Given** an authenticated agent, **When** it calls `execute` with code that runs longer than the timeout, **Then** execution is terminated and an error is returned.
|
||||
|
||||
---
|
||||
|
||||
### User Story 4 - Agent Searches Messages with Filters and Pagination (Priority: P2)
|
||||
|
||||
An agent needs to find specific messages — filtering by date range, sender, channel, or status — and paginate through large result sets. Semantic search can be combined with filters.
|
||||
|
||||
**Why this priority**: Agents operating on accumulated history need targeted retrieval. Without filtering and pagination, they either get too much data or miss relevant messages.
|
||||
|
||||
**Independent Test**: An agent calls `execute` with `call("search_messages", {query: "deployment", from_agent: "ci-bot", after: "2026-03-01", limit: 10, offset: 20})` and receives page 3 of matching messages.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** messages from multiple agents across multiple channels, **When** an agent searches with `from_agent: "deploy-bot"` and `after: "2026-03-10"`, **Then** only messages from deploy-bot after March 10 are returned.
|
||||
2. **Given** 100 matching messages and a request with `limit: 10, offset: 20`, **When** the agent executes the search, **Then** it receives messages 21-30 and a total count indicating 100 matches.
|
||||
3. **Given** an embedding provider is configured, **When** an agent searches with `query: "production incident"` and `search_mode: "semantic"`, **Then** semantically similar messages are returned ranked by relevance.
|
||||
4. **Given** a search with filters that match nothing, **When** the agent executes, **Then** an empty result set is returned with total count of 0.
|
||||
|
||||
---
|
||||
|
||||
### User Story 5 - Human Admin Manages Webhooks and K8s Handlers via CLI (Priority: P2)
|
||||
|
||||
A human administrator uses CLI subcommands to register, list, and delete webhooks and Kubernetes job handlers, and to run attachment garbage collection. These operations are no longer available as MCP tools.
|
||||
|
||||
**Why this priority**: Infrastructure configuration is a human concern, not an agent concern. Moving these to CLI reduces MCP tool surface and token cost.
|
||||
|
||||
**Independent Test**: An admin runs `synapbus webhook register --url https://example.com/hook --events message.received --secret mysecret` and the webhook is created. `synapbus webhook list` shows it.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** a running SynapBus instance, **When** an admin runs `synapbus webhook register --url <url> --events message.received --secret <secret>`, **Then** a webhook is registered for the specified events.
|
||||
2. **Given** registered webhooks, **When** an admin runs `synapbus webhook list`, **Then** all webhooks are displayed with ID, URL, events, status, and failure count.
|
||||
3. **Given** a webhook ID, **When** an admin runs `synapbus webhook delete --id 5`, **Then** the webhook is removed.
|
||||
4. **Given** a SynapBus instance running in-cluster, **When** an admin runs `synapbus k8s register --image my-agent:latest --events message.received`, **Then** a K8s job handler is registered.
|
||||
5. **Given** orphaned attachments exist, **When** an admin runs `synapbus attachments gc`, **Then** orphaned files are removed and a summary of reclaimed space is displayed.
|
||||
|
||||
---
|
||||
|
||||
### User Story 6 - Agent Composes Multi-Step Workflows (Priority: P3)
|
||||
|
||||
An agent executes a complex workflow in a single `execute` call — e.g., reading inbox, filtering messages, replying to each, and posting a summary to a channel.
|
||||
|
||||
**Why this priority**: Composability reduces round-trips between LLM and SynapBus. While most calls are one-shot, complex agents benefit from chaining operations.
|
||||
|
||||
**Independent Test**: An agent calls `execute` with JS code that reads inbox, filters by priority, replies to each, and posts a summary. All operations complete in one tool call.
|
||||
|
||||
**Acceptance Scenarios**:
|
||||
|
||||
1. **Given** an agent with 5 pending messages, **When** it calls `execute` with code that reads inbox, marks each as done, and posts a summary count to channel "ops", **Then** all 5 messages are marked done and the summary is posted.
|
||||
2. **Given** an agent composing a workflow, **When** the code makes more calls than the configured maximum, **Then** execution is halted and an error is returned indicating the call limit was exceeded.
|
||||
|
||||
---
|
||||
|
||||
### Edge Cases
|
||||
|
||||
- What happens when `execute` code contains an infinite loop? Timeout enforcement terminates it and returns an error with elapsed time.
|
||||
- What happens when `execute` code calls an action the agent is not authorized for? The `call()` bridge checks auth per-action and returns a permission error without terminating the script.
|
||||
- What happens when `search` query matches no actions? An empty result set with a suggestion to broaden the query.
|
||||
- What happens when TypeScript code has syntax errors? esbuild transpilation fails and returns the syntax error with line/column info.
|
||||
- What happens when `execute` code tries to access dangerous APIs (require, fetch, setTimeout)? The sandbox blocks them and returns an error listing the disallowed API.
|
||||
- What happens when `send_message` is called with empty body? Validation error returned.
|
||||
- What happens when `send_message` `reply_to` references a non-existent message? Validation error returned.
|
||||
- What happens when `execute` code allocates excessive memory? Memory limit enforcement terminates it and returns an error.
|
||||
- What happens when an agent calls `search` expecting message results? The tool returns action definitions, not messages. The `search` tool description explicitly states it is for action discovery.
|
||||
- What happens when pagination offset exceeds total results? Empty result set returned with the total count.
|
||||
|
||||
## Requirements *(mandatory)*
|
||||
|
||||
### Functional Requirements
|
||||
|
||||
**MCP Tool Surface**
|
||||
|
||||
- **FR-001**: System MUST expose exactly 4 MCP tools: `my_status`, `search`, `execute`, `send_message`.
|
||||
- **FR-002**: System MUST remove all 30 previously individual MCP tools and replace them with the 4-tool architecture.
|
||||
- **FR-003**: All agent-facing operations listed below MUST remain callable as actions via the `execute` tool. The `send_message` action is also accessible as a dedicated MCP tool.
|
||||
|
||||
**Action Catalog** (23 operations, by category):
|
||||
|
||||
| Category | Actions |
|
||||
|----------|---------|
|
||||
| Messaging | `send_message`, `read_inbox`, `claim_messages`, `mark_done`, `search_messages`, `discover_agents` |
|
||||
| Channels | `create_channel`, `join_channel`, `leave_channel`, `list_channels`, `invite_to_channel`, `kick_from_channel`, `get_channel_messages`, `send_channel_message`, `update_channel` |
|
||||
| Swarm | `post_task`, `bid_task`, `accept_bid`, `complete_task`, `list_tasks` |
|
||||
| Attachments | `upload_attachment`, `download_attachment` |
|
||||
|
||||
**my_status Tool**
|
||||
|
||||
- **FR-010**: `my_status` MUST accept zero parameters and return: agent identity, pending direct message count, channel mention count, channel memberships, system notifications, and usage statistics (channels joined, unread channel messages, total messages sent/received).
|
||||
- **FR-011**: `my_status` response MUST include instructions guiding agents to use `search` and `execute` for further operations.
|
||||
|
||||
**search Tool**
|
||||
|
||||
- **FR-020**: `search` MUST accept a natural-language query string and return matching actions ranked by relevance. Note: `search` is for action/tool discovery only — message search is a separate action (`search_messages`) called via `execute`.
|
||||
- **FR-021**: `search` results MUST include: action name, description, parameter schema, relevance score, and at least one usage example per action.
|
||||
- **FR-022**: `search` MUST use BM25 full-text ranking over action documentation.
|
||||
- **FR-023**: `search` MUST accept an optional `limit` parameter (default 5, max 20).
|
||||
|
||||
**execute Tool**
|
||||
|
||||
- **FR-030**: `execute` MUST accept a `code` parameter containing JavaScript or TypeScript source code.
|
||||
- **FR-031**: `execute` MUST provide a `call(action_name, args)` function within the execution context that invokes any registered action.
|
||||
- **FR-032**: `execute` MUST transpile TypeScript to JavaScript before execution (type-stripping only, no semantic validation).
|
||||
- **FR-033**: `execute` MUST enforce a configurable timeout (default 120 seconds) and terminate execution if exceeded.
|
||||
- **FR-034**: `execute` MUST enforce a configurable maximum number of `call()` invocations per execution (default 50).
|
||||
- **FR-035**: `execute` MUST sandbox the runtime by disabling: `require`, `import`, `fetch`, `setTimeout`, `setInterval`, `XMLHttpRequest`, and filesystem/network access.
|
||||
- **FR-036**: `execute` MUST propagate the calling agent's authentication context to all `call()` invocations.
|
||||
- **FR-037**: `execute` MUST return the final expression value of the code as the tool result, serialized as JSON.
|
||||
- **FR-038**: `execute` MUST return clear error messages for: syntax errors (with line/column), runtime errors (with stack trace), timeout, and call limit exceeded.
|
||||
- **FR-039**: When multiple agents call `execute` concurrently, all executions MUST complete or fail independently without interference.
|
||||
- **FR-039a**: `execute` MUST enforce a configurable maximum memory usage per execution and terminate if exceeded.
|
||||
|
||||
**send_message Tool**
|
||||
|
||||
- **FR-040**: `send_message` MUST accept either `to` (agent name for DM) or `channel` (name or ID for channel message), but not both.
|
||||
- **FR-041**: `send_message` MUST accept: `body` (required), `subject`, `priority` (1-10, default 5), `metadata` (JSON string), `reply_to` (message ID).
|
||||
- **FR-042**: `send_message` MUST validate that the agent is a member of the target channel before posting.
|
||||
- **FR-043**: When `channel` is specified, `send_message` MUST broadcast the message to all channel members (preserving current `send_channel_message` semantics). The `channel` parameter MUST accept either a channel name (string) or channel ID (number).
|
||||
- **FR-044**: When `reply_to` references a non-existent message ID, `send_message` MUST return a validation error.
|
||||
|
||||
**Pagination**
|
||||
|
||||
- **FR-050**: All list/read actions MUST support offset-based pagination via `offset` (default 0) and `limit` parameters.
|
||||
- **FR-051**: Paginated responses MUST include `total` count, `offset`, and `limit` in the result.
|
||||
- **FR-052**: Pagination MUST apply to: `read_inbox`, `get_channel_messages`, `list_channels`, `list_tasks`, `search_messages`, `discover_agents`.
|
||||
|
||||
**Advanced Filtering**
|
||||
|
||||
- **FR-060**: `search_messages` action MUST support filtering by: `after` (ISO 8601 date), `before` (ISO 8601 date), `from_agent`, `channel`, `status`.
|
||||
- **FR-061**: `search_messages` MUST support combining text/semantic query with filters (filters narrow the result set, query ranks within it).
|
||||
- **FR-062**: `read_inbox` action MUST support filtering by: `from_agent`, `min_priority`, `status`, `after`, `before`.
|
||||
|
||||
**CLI Subcommands**
|
||||
|
||||
- **FR-070**: System MUST provide `synapbus webhook register|list|delete` CLI subcommands with equivalent functionality to the removed MCP tools.
|
||||
- **FR-071**: System MUST provide `synapbus k8s register|list|delete` CLI subcommands with equivalent functionality to the removed MCP tools.
|
||||
- **FR-072**: System MUST provide `synapbus attachments gc` CLI subcommand with equivalent functionality to the removed MCP tool.
|
||||
- **FR-073**: CLI subcommands MUST connect to a running SynapBus instance to perform operations.
|
||||
|
||||
### Key Entities
|
||||
|
||||
- **Action**: A callable operation with a name, category (messaging/channels/swarm/attachments), description, parameter schema, return schema, and usage examples. Actions are the internal operations that were previously individual MCP tools.
|
||||
- **Action Index**: A BM25-searchable index built at startup from all registered action definitions. Rebuilt when actions change.
|
||||
- **Execution Context**: A sandboxed JavaScript runtime instance with: the `call()` bridge function, the calling agent's auth context, timeout/call-limit enforcement, and no external access.
|
||||
|
||||
## Success Criteria *(mandatory)*
|
||||
|
||||
### Measurable Outcomes
|
||||
|
||||
- **SC-001**: MCP tool definitions sent to agents are reduced from 30 to 4.
|
||||
- **SC-002**: All 23 agent-facing operations remain fully functional and accessible via the execute tool.
|
||||
- **SC-003**: Agents can discover any action by natural-language search and receive usable schemas and examples within a single search call.
|
||||
- **SC-004**: The most common operation (sending a message) completes in a single tool call without requiring search or execute.
|
||||
- **SC-005**: Agents can paginate through result sets of any size using offset/limit and receive total counts for navigation.
|
||||
- **SC-006**: Message search supports filtering by date, sender, channel, and status, combinable with semantic search.
|
||||
- **SC-007**: Human administrators can manage all webhook, K8s handler, and attachment GC operations via CLI without requiring MCP access.
|
||||
- **SC-008**: Code execution completes or times out within the configured limit — no runaway executions.
|
||||
- **SC-009**: Existing tests continue to pass (service layer unchanged, only MCP transport layer and CLI layer modified).
|
||||
|
||||
## Assumptions
|
||||
|
||||
- Agents are Claude/GPT-class models capable of writing JavaScript/TypeScript code reliably.
|
||||
- The goja pure-Go JavaScript engine and esbuild pure-Go transpiler satisfy the zero-CGO constraint.
|
||||
- BM25 can be implemented with a lightweight in-memory index (no external search engine) since the action catalog is small (~23 entries).
|
||||
- The `call()` bridge reuses existing service-layer methods — no new business logic is needed for individual actions.
|
||||
- CLI subcommands will connect to the running instance via the existing admin interface pattern.
|
||||
- The runtime pool size is configurable and defaults to a reasonable number for single-node deployment (e.g., 10 concurrent runtimes).
|
||||
- This is a breaking change. Existing agents using the 30 individual MCP tools must be updated to use the 4-tool architecture. No backward compatibility layer is provided.
|
||||
- TypeScript transpilation uses esbuild (pure Go, zero CGO). BM25 search uses a lightweight in-memory implementation.
|
||||
@@ -0,0 +1,35 @@
|
||||
# Specification Quality Checklist: Admin CLI & Docker Fixes
|
||||
|
||||
**Purpose**: Validate specification completeness and quality before proceeding to planning
|
||||
**Created**: 2026-03-15
|
||||
**Feature**: [spec.md](../spec.md)
|
||||
|
||||
## Content Quality
|
||||
|
||||
- [x] No implementation details (languages, frameworks, APIs)
|
||||
- [x] Focused on user value and business needs
|
||||
- [x] Written for non-technical stakeholders
|
||||
- [x] All mandatory sections completed
|
||||
|
||||
## Requirement Completeness
|
||||
|
||||
- [x] No [NEEDS CLARIFICATION] markers remain
|
||||
- [x] Requirements are testable and unambiguous
|
||||
- [x] Success criteria are measurable
|
||||
- [x] Success criteria are technology-agnostic (no implementation details)
|
||||
- [x] All acceptance scenarios are defined
|
||||
- [x] Edge cases are identified
|
||||
- [x] Scope is clearly bounded
|
||||
- [x] Dependencies and assumptions identified
|
||||
|
||||
## Feature Readiness
|
||||
|
||||
- [x] All functional requirements have clear acceptance criteria
|
||||
- [x] User scenarios cover primary flows
|
||||
- [x] Feature meets measurable outcomes defined in Success Criteria
|
||||
- [x] No implementation details leak into specification
|
||||
|
||||
## Notes
|
||||
|
||||
- All items pass. Spec is ready for `/speckit.plan`.
|
||||
- FR-001 mentions "alpine:3.19" which is an implementation detail, but this is the explicit user request and core to the fix, so it's acceptable.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user