Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

6.3 KB
Raw Blame
package handler

import (
	"net/http"
	"strings"

	"github.com/Tencent/WeKnora/internal/sandbox"
	"github.com/gin-gonic/gin"
)

// DeploymentCapabilityKeys is the canonical capability key list shared with
// frontend/src/config/deploymentCapabilities.ts — keep both in sync.
var DeploymentCapabilityKeys = []string{
	"organizations",
	"agents",
	"integrations.im",
	"integrations.embed",
	"integrations.api",
	"integrations.mcpserver",
	"settings.mcp",
	"settings.websearch",
	"settings.vectorstore",
	"settings.storage",
	"settings.sandbox",
	"settings.sandbox.docker",
	"settings.sandbox.host",
	"settings.sandbox.remote",
	"settings.sandbox.user_allocation",
}

// DeploymentCapability describes whether a deployment exposes a feature route.
type DeploymentCapability struct {
	Supported bool   `json:"supported"`
	Reason    string `json:"reason,omitempty"`
}

// DeploymentCapabilitiesData is returned by GET /system/capabilities.
type DeploymentCapabilitiesData struct {
	Edition      string                          `json:"edition"`
	Capabilities map[string]DeploymentCapability `json:"capabilities"`
}

// DeploymentFeatureAvailability mirrors injected backend handlers/services.
type DeploymentFeatureAvailability struct {
	Organizations         bool
	Agents                bool
	IM                    bool
	Embed                 bool
	API                   bool
	MCPServer             bool
	MCP                   bool
	WebSearch             bool
	VectorStore           bool
	Storage               bool
	Sandbox               bool
	SandboxDocker         bool
	SandboxHost           bool
	SandboxRemote         bool
	SandboxUserAllocation bool
}

func supportedDeploymentCapability(supported bool) DeploymentCapability {
	if supported {
		return DeploymentCapability{Supported: true}
	}
	return DeploymentCapability{Supported: false, Reason: "route_not_registered"}
}

// BuildDeploymentCapabilities derives the deployment capability snapshot.
func BuildDeploymentCapabilities(
	edition string,
	available DeploymentFeatureAvailability,
) DeploymentCapabilitiesData {
	isLite := strings.EqualFold(strings.TrimSpace(edition), "lite")
	organizations := supportedDeploymentCapability(available.Organizations && !isLite)
	if isLite {
		organizations.Reason = "not_supported_in_lite"
	}

	sandboxDocker := DeploymentCapability{
		Supported: available.Sandbox && available.SandboxDocker,
	}
	if available.Sandbox && !available.SandboxDocker {
		sandboxDocker.Reason = "docker_backend_disabled"
	} else if !available.Sandbox {
		sandboxDocker.Reason = "route_not_registered"
	}

	sandboxHost := DeploymentCapability{
		Supported: available.Sandbox && available.SandboxHost,
	}
	if available.Sandbox && !available.SandboxHost {
		// The platform has no OS-enforced backend (Windows/Linux today).
		sandboxHost.Reason = "platform_unsupported"
	} else if !available.Sandbox {
		sandboxHost.Reason = "route_not_registered"
	}

	sandboxRemote := DeploymentCapability{Supported: available.Sandbox && available.SandboxRemote}
	if available.Sandbox && !available.SandboxRemote {
		sandboxRemote.Reason = "not_supported_in_lite"
	} else if !available.Sandbox {
		sandboxRemote.Reason = "route_not_registered"
	}

	sandboxUserAllocation := DeploymentCapability{
		Supported: sandboxRemote.Supported && available.SandboxUserAllocation,
	}
	if !sandboxUserAllocation.Supported {
		sandboxUserAllocation.Reason = "deployment_gate_off"
		if !sandboxRemote.Supported {
			sandboxUserAllocation.Reason = sandboxRemote.Reason
		}
	}

	return DeploymentCapabilitiesData{
		Edition: edition,
		Capabilities: map[string]DeploymentCapability{
			"organizations":                    organizations,
			"agents":                           supportedDeploymentCapability(available.Agents),
			"integrations.im":                  supportedDeploymentCapability(available.IM),
			"integrations.embed":               supportedDeploymentCapability(available.Embed),
			"integrations.api":                 supportedDeploymentCapability(available.API),
			"integrations.mcpserver":           supportedDeploymentCapability(available.MCPServer),
			"settings.mcp":                     supportedDeploymentCapability(available.MCP),
			"settings.websearch":               supportedDeploymentCapability(available.WebSearch),
			"settings.vectorstore":             supportedDeploymentCapability(available.VectorStore),
			"settings.storage":                 supportedDeploymentCapability(available.Storage),
			"settings.sandbox":                 supportedDeploymentCapability(available.Sandbox),
			"settings.sandbox.docker":          sandboxDocker,
			"settings.sandbox.host":            sandboxHost,
			"settings.sandbox.remote":          sandboxRemote,
			"settings.sandbox.user_allocation": sandboxUserAllocation,
		},
	}
}

// BindDeploymentCapabilities stores the startup snapshot used by GetDeploymentCapabilities.
func (h *SystemHandler) BindDeploymentCapabilities(data DeploymentCapabilitiesData) {
	h.deploymentCapabilities = data
}

// GetDeploymentCapabilities godoc
// @Summary      获取部署能力清单
// @Description  返回当前部署版本及实际注册的后端路由所对应的功能能力;仅 supported=false 表示入口应隐藏
// @Tags         系统
// @Produce      json
// @Success 200 {object} handler.GetDeploymentCapabilitiesResponse
// @Router       /system/capabilities [get]
func (h *SystemHandler) GetDeploymentCapabilities(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"code": 0,
		"msg":  "success",
		"data": overlayLiveDockerSandboxCapability(h.deploymentCapabilities),
	})
}

// overlayLiveDockerSandboxCapability replaces the startup snapshot's Docker
// flag with the live 3-tier value so a System Settings toggle is visible
// without restarting the process.
func overlayLiveDockerSandboxCapability(data DeploymentCapabilitiesData) DeploymentCapabilitiesData {
	caps := make(map[string]DeploymentCapability, len(data.Capabilities))
	for key, capability := range data.Capabilities {
		caps[key] = capability
	}
	sandboxCap := caps["settings.sandbox"]
	docker := DeploymentCapability{
		Supported: sandboxCap.Supported && sandbox.DockerBackendEnabled(),
	}
	if sandboxCap.Supported && !docker.Supported {
		docker.Reason = "docker_backend_disabled"
	} else if !sandboxCap.Supported {
		docker.Reason = "route_not_registered"
	}
	caps["settings.sandbox.docker"] = docker
	data.Capabilities = caps
	return data
}