package cli import ( "context" "encoding/json" "fmt" "net/http" "net/url" "slices" "strconv" "strings" "time" tea "github.com/charmbracelet/bubbletea" "gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi" "gitea.mynodes.xyz/ilker/llmgw/internal/store" ) // The company's own MCP servers, as the console shows them: each with its // address, the names of the credentials it is sent (never their values), // its rate, and who has been granted its tools; Enter for what can be done // to one, A to add one. Clients reach them all through the gateway's /mcp // with an llmgw key, as server.tool. type mcpState struct { servers []adminapi.MCPServerView err error loaded bool // grants are the tool grants in the tenancy tree, nil when the store // could not be read from here; where says what each scope's ID is // called, and ids the other way, for the grant form. grants []mcpGrant where map[string]string ids map[string]store.LimitOwner // keys are the IDs of the keys there are, for a grant to one. keys map[string]bool } // mcpGrant is one level of the tree that grants tools, and which. type mcpGrant struct { owner store.LimitOwner label string tools []string } type consoleMCPMsg mcpState func (m consoleModel) fetchMCP() tea.Cmd { c, h := m.client, m.st return func() tea.Msg { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() var msg consoleMCPMsg msg.err = c.get(ctx, "/api/v1/mcp/servers", &msg.servers) msg.loaded = true if h == nil { return msg } s, err := h.get(ctx) if err != nil { return msg } limits, err := s.AllLimits(ctx) if err != nil { return msg } msg.where, msg.ids = map[string]string{}, map[string]store.LimitOwner{} if tree, err := s.Tree(ctx); err == nil { for _, o := range tree { msg.name(store.ScopeOrg, o.ID, o.Name) for _, t := range o.Teams { msg.name(store.ScopeTeam, t.ID, o.Name+"/"+t.Name) for _, p := range t.Projects { msg.name(store.ScopeProject, p.ID, o.Name+"/"+t.Name+"/"+p.Name) } } } } if users, err := s.Users(ctx, ""); err == nil { for _, u := range users { msg.name(store.ScopeUser, u.ID, u.Email) } } msg.keys = map[string]bool{} if keys, err := s.AllKeys(ctx); err == nil { for _, k := range keys { msg.keys[k.ID] = true msg.where[store.LimitOwner{Scope: store.ScopeKey, ID: k.ID}.CounterKey()] = k.Name } } msg.grants = []mcpGrant{} for _, l := range limits { if l.AllowedTools == nil { continue } o := store.LimitOwner{Scope: l.Scope, ID: l.ScopeID} label := msg.where[o.CounterKey()] if label == "" { label = l.ScopeID } msg.grants = append(msg.grants, mcpGrant{owner: o, label: string(l.Scope) + " " + label, tools: l.AllowedTools}) } slices.SortFunc(msg.grants, func(a, b mcpGrant) int { return strings.Compare(a.label, b.label) }) return msg } } func (s *consoleMCPMsg) name(scope store.Scope, id, label string) { o := store.LimitOwner{Scope: scope, ID: id} s.where[o.CounterKey()] = label s.ids[string(scope)+":"+strings.ToLower(label)] = o if m := store.MemberScope(scope); m != "" { s.where[store.LimitOwner{Scope: m, ID: id}.CounterKey()] = label } } // closed are the levels whose list names no tool at all. func (k mcpState) closed() []mcpGrant { var out []mcpGrant for _, g := range k.grants { if len(g.tools) == 0 { out = append(out, g) } } return out } // mcpGrantsOf is who may use a server's tools, and which of them. func (k mcpState) grantsOf(server string) []mcpGrant { var out []mcpGrant for _, g := range k.grants { var mine []string for _, t := range g.tools { if strings.HasPrefix(t, server+".") || t == "*" { mine = append(mine, t) } } if len(mine) > 0 { out = append(out, mcpGrant{owner: g.owner, label: g.label, tools: mine}) } } return out } func (m consoleModel) mcpPanel(pw int) (string, string, string) { keys := "→ or Enter open · ↑↓ choose · Q leave" if m.inPanel { keys = "↑↓ server · Enter actions · A add a server · ← back · Q leave" } k := m.mcp var b strings.Builder b.WriteString("\n " + sDim.Render("The company's MCP servers, offered to agents through the gateway's /mcp as server.tool.") + "\n\n") switch { case k.err != nil: b.WriteString(" " + sBad.Render(k.err.Error())) return "MCP servers", b.String(), keys case !k.loaded: b.WriteString(" " + sDim.Render("asking the control plane…")) return "MCP servers", b.String(), keys case len(k.servers) == 0: b.WriteString(" " + sDim.Render("None yet. A to add one: its address, and the credential it wants.")) b.WriteString("\n\n" + mcpClientHint()) return "MCP servers", b.String(), keys } var rows [][]string for _, s := range k.servers { state := sOK.Render("on") if !s.Enabled { state = sDim.Render("off") } granted := "—" if k.grants != nil { var who []string for _, g := range k.grantsOf(s.Name) { who = append(who, g.label) } granted = sBad.Render("nobody yet") if len(who) > 0 { granted = strings.Join(who, ", ") } } rate := "—" if s.RatePerMinute > 0 { rate = fmt.Sprintf("%d/min", s.RatePerMinute) } rows = append(rows, []string{s.Name, state, granted, rate, dash(strings.Join(mcpCredentials(s), ", ")), s.URL}) } b.WriteString(table([]string{"SERVER", "STATE", "GRANTED TO", "RATE", "SENT", "ADDRESS"}, rows, m.row, pw, m.inPanel)) b.WriteString("\n\n " + sDim.Render("A server's tools are seen only where they are granted; nothing is granted by default.") + "\n") if closed := k.closed(); len(closed) > 0 { var names []string for _, g := range closed { names = append(names, g.label) } b.WriteString(" " + sBad.Render("Closed to every tool: ") + strings.Join(names, ", ") + sDim.Render(" (a server's menu opens them)") + "\n") } b.WriteString("\n") b.WriteString(mcpClientHint()) return "MCP servers", b.String(), keys } // mcpClientHint is how a person's agent is pointed at the gateway. func mcpClientHint() string { return " " + sDim.Render("In a person's agent: the gateway's https://…/mcp, with their key from /profile/keys") + "\n" + " " + sDim.Render(" claude mcp add --transport http company https://HOST/mcp --header \"Authorization: Bearer sk-llmgw-…\"") } // mcpCredentials are the names of the headers a server is sent: which are // kept as secrets and which as written. Never their values. func mcpCredentials(s adminapi.MCPServerView) []string { var out []string for h := range s.HeaderRefs { out = append(out, h+" (secret)") } for h := range s.Headers { out = append(out, h) } slices.Sort(out) return out } // mcpPath is a server's admin API address. func mcpPath(name string) string { return "/api/v1/mcp/servers/" + url.PathEscape(name) } // mcpAuth turns the form's credential fields into what the server is sent: // a bearer token, another header, or nothing. func mcpAuth(kind, header, secret string) (map[string]string, error) { switch kind { case "none": return nil, nil case "bearer": if secret == "" { return nil, nil } return map[string]string{"Authorization": "Bearer " + strings.TrimPrefix(secret, "Bearer ")}, nil default: if header == "" { return nil, fmt.Errorf("which header carries the credential?") } if secret == "" { return nil, nil } return map[string]string{header: secret}, nil } } func atoiOr(s string, def int) (int, error) { if strings.TrimSpace(s) == "" { return def, nil } return strconv.Atoi(strings.TrimSpace(s)) } // mcpAddForm registers a server. func (m *consoleModel) mcpAddForm() { m.openForm(&formDialog{title: "Add an MCP server", note: "Reached by the control plane over HTTP (streamable HTTP or SSE). Its credential is kept in\n" + "the store, sealed, and never reaches a client. Its tools are seen nowhere until granted.", fields: []formField{ textF("name", "", "lowercase, the tools' prefix: jira → jira.search"), textF("address", "", "https://jira-mcp.internal/mcp"), textF("about", "", "what it is for, in a line"), choiceF("credential", []string{"bearer", "header", "none"}, "bearer"), textF("header", "", "for credential: header, its name (X-Api-Key)"), pwF("secret", "the token or key; kept sealed in the store"), textF("timeout", "", "seconds a call may take; empty is the default"), textF("rate", "", "calls a minute per caller; empty is no bound"), }, submit: func(m *consoleModel, v []string) (tea.Cmd, error) { name, addr := strings.TrimSpace(v[0]), strings.TrimSpace(v[1]) if name == "" || addr == "" { return nil, fmt.Errorf("a name and an address") } if err := adminapi.CheckMCPAddress(addr); err != nil { return nil, err } secrets, err := mcpAuth(v[3], strings.TrimSpace(v[4]), v[5]) if err != nil { return nil, err } timeout, err := atoiOr(v[6], 0) if err != nil || timeout < 0 { return nil, fmt.Errorf("timeout is whole seconds") } rate, err := atoiOr(v[7], 0) if err != nil || rate < 0 { return nil, fmt.Errorf("rate is calls a minute") } on := true req := adminapi.MCPServerRequest{URL: addr, Description: v[2], Secrets: secrets, Enabled: &on, TimeoutSeconds: timeout, RatePerMinute: rate} return m.call("Add "+name, http.MethodPut, mcpPath(name), req, func(json.RawMessage) string { return "Added " + name + ". Test it from its menu, then grant its tools: nobody sees them yet." }), nil }}) } // mcpMenu is what can be done to one server. func (m consoleModel) mcpMenu(s adminapi.MCPServerView) *menuDialog { items := []menuItem{ {"Test, and list its tools", func(m *consoleModel) tea.Cmd { return m.mcpTest(s) }}, {"Grant its tools to…", func(m *consoleModel) tea.Cmd { m.mcpGrantForm(s); return nil }}, } for _, g := range m.mcp.grantsOf(s.Name) { if !slices.ContainsFunc(g.tools, func(t string) bool { return t != "*" }) { continue // every tool, granted with the Limits form; revoked there too } items = append(items, menuItem{"Revoke from " + g.label + " (" + strings.Join(g.tools, ", ") + ")…", func(m *consoleModel) tea.Cmd { m.confirmD = &confirmDialog{title: "Revoke " + s.Name + " from " + g.label, text: "Taken from it and from everything beneath it. Its other grants stay; left naming\n" + "no tool, it is closed rather than opened to what the levels above allow.", yes: func(m *consoleModel) tea.Cmd { return m.mcpSetTools(s.Name, g.owner, nil) }} return nil }}) } for _, g := range m.mcp.closed() { items = append(items, menuItem{"Open " + g.label + ", closed to every tool…", func(m *consoleModel) tea.Cmd { m.confirmD = &confirmDialog{title: "Open " + g.label, text: "It then names no tools of its own and sees what the levels above it allow.", yes: func(m *consoleModel) tea.Cmd { return m.mcpOpen(g.owner) }} return nil }}) } items = append(items, menuItem{"Change…", func(m *consoleModel) tea.Cmd { m.mcpEditForm(s); return nil }}, menuItem{"Replace its credential…", func(m *consoleModel) tea.Cmd { m.mcpCredentialForm(s); return nil }}, ) if s.Enabled { items = append(items, menuItem{"Turn off", func(m *consoleModel) tea.Cmd { off := false return m.call("Turn off "+s.Name, http.MethodPut, mcpPath(s.Name), adminapi.MCPServerRequest{URL: s.URL, Enabled: &off}, func(json.RawMessage) string { return s.Name + " is off: its tools are listed nowhere and every call is refused." }) }}) } else { items = append(items, menuItem{"Turn on", func(m *consoleModel) tea.Cmd { on := true return m.call("Turn on "+s.Name, http.MethodPut, mcpPath(s.Name), adminapi.MCPServerRequest{URL: s.URL, Enabled: &on}, nil) }}) } items = append(items, menuItem{"Remove…", func(m *consoleModel) tea.Cmd { m.confirmD = &confirmDialog{title: "Remove " + s.Name, text: "Its tools go from every agent at once, and its sealed credential with it.\nThe grants stay in the tree until revoked.", yes: func(m *consoleModel) tea.Cmd { return m.call("Remove "+s.Name, http.MethodDelete, mcpPath(s.Name), nil, nil) }} return nil }}) return &menuDialog{title: s.Name + " · " + s.URL, items: items} } // mcpTest asks the server for its tools, with its credentials, as a call // through the gateway would. func (m *consoleModel) mcpTest(s adminapi.MCPServerView) tea.Cmd { return m.call("Test "+s.Name, http.MethodPost, mcpPath(s.Name)+"/test", nil, func(raw json.RawMessage) string { var t adminapi.MCPTestView _ = json.Unmarshal(raw, &t) if !t.OK { return "It did not answer: " + t.Error } if len(t.Tools) == 0 { return "It answers, and offers no tools." } return fmt.Sprintf("It answers, with %d tools:\n\n %s", len(t.Tools), strings.Join(t.Tools, "\n ")) }) } func (m *consoleModel) mcpEditForm(s adminapi.MCPServerView) { rate := "" if s.RatePerMinute > 0 { rate = strconv.Itoa(s.RatePerMinute) } timeout := "" if s.TimeoutSeconds > 0 { timeout = strconv.Itoa(s.TimeoutSeconds) } m.openForm(&formDialog{title: "Change " + s.Name, note: "Its credential stays as it is; Replace its credential for that.", fields: []formField{ textF("address", s.URL, ""), textF("about", s.Description, ""), textF("timeout", timeout, "seconds a call may take"), textF("rate", rate, "calls a minute per caller; 0 is no bound"), }, submit: func(m *consoleModel, v []string) (tea.Cmd, error) { if err := adminapi.CheckMCPAddress(strings.TrimSpace(v[0])); err != nil { return nil, err } timeout, err := atoiOr(v[2], 0) if err != nil || timeout < 0 { return nil, fmt.Errorf("timeout is whole seconds") } rate, err := atoiOr(v[3], 0) if err != nil || rate < 0 { return nil, fmt.Errorf("rate is calls a minute") } req := adminapi.MCPServerRequest{URL: strings.TrimSpace(v[0]), Description: v[1], TimeoutSeconds: timeout, RatePerMinute: rate} // An emptied field empties it, rather than leaving it as it was. if strings.TrimSpace(v[1]) == "" { req.Clear = append(req.Clear, "description") } if timeout == 0 { req.Clear = append(req.Clear, "timeout") } if rate == 0 { req.Clear = append(req.Clear, "rate") } return m.call("Change "+s.Name, http.MethodPut, mcpPath(s.Name), req, nil), nil }}) } func (m *consoleModel) mcpCredentialForm(s adminapi.MCPServerView) { m.openForm(&formDialog{title: "Replace the credential " + s.Name + " is sent", note: "Kept in the store, sealed. The old value is overwritten, not shown.", fields: []formField{ choiceF("credential", []string{"bearer", "header"}, "bearer"), textF("header", "", "for credential: header, its name (X-Api-Key)"), pwF("secret", "the token or key"), }, submit: func(m *consoleModel, v []string) (tea.Cmd, error) { if v[2] == "" { return nil, fmt.Errorf("the new secret?") } secrets, err := mcpAuth(v[0], strings.TrimSpace(v[1]), v[2]) if err != nil { return nil, err } return m.call("Credential of "+s.Name, http.MethodPut, mcpPath(s.Name), adminapi.MCPServerRequest{URL: s.URL, Secrets: secrets, HeaderRefs: map[string]string{}}, nil), nil }}) } // mcpGrantForm grants a server's tools to part of the tree, a person or a // key, beside whatever else that level is granted. func (m *consoleModel) mcpGrantForm(s adminapi.MCPServerView) { if m.mcp.ids == nil { m.dialog, m.dialogTitle = "error", "Grant "+s.Name m.dialogText = "The store cannot be read from this machine, so its grants cannot be changed here.\n" + "On the control plane: llmgw keys limits --scope team --id ORG/TEAM --tools '" + s.Name + ".*'" return } m.openForm(&formDialog{title: "Grant " + s.Name + "'s tools", note: "Seen there, and below, where every level above that names tools names these too.\n" + "A level given its first grant keeps what it saw from above; other grants stay.", fields: []formField{ choiceF("to", []string{"team", "project", "org", "user", "key"}, "team"), textF("which", "", "ORG/TEAM/PROJECT, ORG/TEAM, ORG, an e-mail, or a key's ID"), textF("tools", s.Name+".*", "patterns: "+s.Name+".* for all, or "+s.Name+".search,"+s.Name+".get"), }, submit: func(m *consoleModel, v []string) (tea.Cmd, error) { which := strings.TrimSpace(v[1]) if which == "" { return nil, fmt.Errorf("which %s?", v[0]) } owner, ok := m.mcp.ids[v[0]+":"+strings.ToLower(which)] if v[0] == "key" { owner, ok = store.LimitOwner{Scope: store.ScopeKey, ID: which}, m.mcp.keys[which] } if !ok { return nil, fmt.Errorf("no %s %q", v[0], which) } var tools []string for _, t := range strings.Split(v[2], ",") { if t = strings.TrimSpace(t); t != "" { if !strings.HasPrefix(t, s.Name+".") { return nil, fmt.Errorf("%q is not one of %s's tools: they start %s.", t, s.Name, s.Name) } tools = append(tools, t) } } if len(tools) == 0 { return nil, fmt.Errorf("which tools? %s.* for all", s.Name) } return m.mcpSetTools(s.Name, owner, tools), nil }}) } // mcpSetTools grants a level these of a server's tools, or with none takes // them away, in the store (store.GrantTools, store.RevokeTools): read and // written at once, so another administrator's change since this screen // was loaded is kept. func (m *consoleModel) mcpSetTools(server string, owner store.LimitOwner, tools []string) tea.Cmd { h, where := m.st, m.mcp.where title := "Grant " + server if len(tools) == 0 { title = "Revoke " + server } return func() tea.Msg { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() s, err := h.get(ctx) if err != nil { return actionDoneMsg{title: title, err: err} } if len(tools) == 0 { if err := s.RevokeTools(ctx, owner.Scope, owner.ID, server); err != nil { return actionDoneMsg{title: title, err: err} } return actionDoneMsg{title: title, text: server + "'s tools taken back there; its other grants stay."} } g, err := s.GrantTools(ctx, owner.Scope, owner.ID, server, tools) if err != nil { return actionDoneMsg{title: title, err: err} } text := "Granted " + strings.Join(tools, ", ") + "." for _, b := range g.BlockedBy { text += "\n\nBut " + string(b.Scope) + " " + or(where[b.CounterKey()], b.ID) + " names tools and not these:\n" + server + "'s stay out of reach there until it grants them too." } return actionDoneMsg{title: title, text: text} } } // mcpOpen has a closed level name no tools of its own (store.OpenTools). func (m *consoleModel) mcpOpen(owner store.LimitOwner) tea.Cmd { h := m.st return func() tea.Msg { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() s, err := h.get(ctx) if err == nil { err = s.OpenTools(ctx, owner.Scope, owner.ID) } if err != nil { return actionDoneMsg{title: "Open", err: err} } return actionDoneMsg{title: "Open", text: "Opened: it names no tools of its own now."} } }