package server import ( "context" "errors" "net" "time" "git.a-wan.net/alan/pipelines/internal/chattools" ) // chatToolTokenStore persists the MCP endpoint tokens (pipeline.Store). type chatToolTokenStore interface { ChatToolToken(ctx context.Context, scope string) (string, error) IssueChatToolToken(ctx context.Context, scope string) (string, error) ChatToolScope(ctx context.Context, token string) (string, bool, error) BindChatToolToken(ctx context.Context, token, scope string) error } // The token scopes. const ( chatToolSessionScope = "session:" chatToolPendingScope = "pending:" chatToolInstanceScope = "instance:" ) // chatToolPath is the loopback route prefix of the MCP endpoint. The web proxy // and the peer relay forward an allowlist that does not include it. const chatToolPath = "/mcp/chat/" // chatToolRegistry issues the endpoint URLs harnesses register // (chattools.Registry) on the server's own loopback listener. type chatToolRegistry struct { store chatToolTokenStore base string } func (r chatToolRegistry) url(token string) string { return r.base + chatToolPath + token } func (r chatToolRegistry) SessionURL(sessionID string) (string, error) { if !validChatSessionID(sessionID) { return "", errors.New("invalid chat session id") } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() token, err := r.store.ChatToolToken(ctx, chatToolSessionScope+sessionID) if err != nil { return "", err } return r.url(token), nil } func (r chatToolRegistry) PendingURL() (string, func(string) error, error) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() token, err := r.store.IssueChatToolToken(ctx, chatToolPendingScope) if err != nil { return "", nil, err } bind := func(sessionID string) error { if !validChatSessionID(sessionID) { return errors.New("invalid chat session id") } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() return r.store.BindChatToolToken(ctx, token, chatToolSessionScope+sessionID) } return r.url(token), bind, nil } func (r chatToolRegistry) InstanceURL(harness string) (string, error) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() token, err := r.store.ChatToolToken(ctx, chatToolInstanceScope+harness) if err != nil { return "", err } return r.url(token), nil } // loopbackBase is the http origin harnesses on this machine use to reach a // server listening on addr: a wildcard or blank host becomes 127.0.0.1. A // server bound only to a non-loopback address cannot serve the tools: the // endpoint answers loopback peers alone. func loopbackBase(addr string) (string, error) { host, port, err := net.SplitHostPort(addr) if err != nil { return "", err } ip := net.ParseIP(host) switch { case host == "localhost" || (ip != nil && ip.IsLoopback()): return "http://" + net.JoinHostPort(host, port), nil case host == "" || (ip != nil && ip.IsUnspecified()): return "http://" + net.JoinHostPort("127.0.0.1", port), nil } return "", errors.New("the chat tools need a loopback or wildcard listen address, not " + addr) } // ConfigureChatTools makes every chat harness Pipelines launches register the // Pipelines MCP server on the listener at addr. It is called once at startup, // before any harness starts. func ConfigureChatTools(store chatToolTokenStore, addr string) error { base, err := loopbackBase(addr) if err != nil { return err } chattools.Configure(chatToolRegistry{store: store, base: base}) return nil }