375 lines
9.6 KiB
Go
375 lines
9.6 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"verstak/internal/core/config"
|
|
"verstak/internal/core/plugins"
|
|
|
|
lua "github.com/yuin/gopher-lua"
|
|
)
|
|
|
|
// PluginDTO represents a discovered plugin with its current state.
|
|
type PluginDTO struct {
|
|
Name string `json:"name"`
|
|
Version string `json:"version"`
|
|
Author string `json:"author,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
Active bool `json:"active"`
|
|
Installed bool `json:"installed"`
|
|
HasInstall bool `json:"hasInstall"`
|
|
HasPanel bool `json:"hasPanel"`
|
|
HasSettings bool `json:"hasSettings"`
|
|
UIContribs UIContribDTO `json:"uiContribs"`
|
|
}
|
|
|
|
// UIContribDTO describes what a plugin adds to the UI.
|
|
type UIContribDTO struct {
|
|
SidebarItems []SidebarItemDTO `json:"sidebarItems"`
|
|
NodeTabs []NodeTabDTO `json:"nodeTabs"`
|
|
}
|
|
|
|
type SidebarItemDTO struct {
|
|
ID string `json:"id"`
|
|
Label string `json:"label"`
|
|
Icon string `json:"icon,omitempty"`
|
|
}
|
|
|
|
type NodeTabDTO struct {
|
|
ID string `json:"id"`
|
|
Label string `json:"label"`
|
|
Page string `json:"page"`
|
|
}
|
|
|
|
// ListPlugins returns all discovered plugins with their current enabled/disabled state.
|
|
func (a *App) ListPlugins() []PluginDTO {
|
|
if a.plugins == nil {
|
|
return nil
|
|
}
|
|
all := a.plugins.Plugins()
|
|
out := make([]PluginDTO, 0, len(all))
|
|
|
|
appCfg, _ := config.LoadAppConfig()
|
|
enabledSet := make(map[string]bool)
|
|
if appCfg != nil {
|
|
for _, name := range appCfg.EnabledPlugins {
|
|
enabledSet[name] = true
|
|
}
|
|
}
|
|
|
|
for _, p := range all {
|
|
active := enabledSet[p.Meta.Name] || p.Active
|
|
contribs := UIContribDTO{}
|
|
for _, item := range p.Meta.UI.SidebarItems {
|
|
contribs.SidebarItems = append(contribs.SidebarItems, SidebarItemDTO{
|
|
ID: item.ID,
|
|
Label: item.Label,
|
|
Icon: item.Icon,
|
|
})
|
|
}
|
|
for _, tab := range p.Meta.UI.NodeTabs {
|
|
contribs.NodeTabs = append(contribs.NodeTabs, NodeTabDTO{
|
|
ID: tab.ID,
|
|
Label: tab.Label,
|
|
Page: tab.Page,
|
|
})
|
|
}
|
|
|
|
hasPanel := false
|
|
if p.Meta.Panel != "" {
|
|
panelPath := filepath.Join(p.Dir, p.Meta.Panel)
|
|
if _, err := os.Stat(panelPath); err == nil {
|
|
hasPanel = true
|
|
}
|
|
}
|
|
|
|
out = append(out, PluginDTO{
|
|
Name: p.Meta.Name,
|
|
Version: p.Meta.Version,
|
|
Author: p.Meta.Author,
|
|
Description: p.Meta.Description,
|
|
Active: active,
|
|
Installed: p.Installed,
|
|
HasInstall: p.HasInstall,
|
|
HasPanel: hasPanel,
|
|
UIContribs: contribs,
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
// SetPluginEnabled persists the enabled/disabled state and applies it to the runtime.
|
|
// Returns error if the plugin is not installed but has install lifecycle.
|
|
func (a *App) SetPluginEnabled(name string, enabled bool) error {
|
|
if a.plugins == nil {
|
|
return fmt.Errorf("plugin manager not ready")
|
|
}
|
|
|
|
if enabled {
|
|
if err := a.plugins.Enable(name); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err := a.plugins.Disable(name); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
appCfg, _ := config.LoadAppConfig()
|
|
if appCfg == nil {
|
|
appCfg = config.DefaultAppConfig()
|
|
}
|
|
|
|
existing := make(map[string]bool)
|
|
for _, n := range appCfg.EnabledPlugins {
|
|
existing[n] = true
|
|
}
|
|
if enabled {
|
|
existing[name] = true
|
|
} else {
|
|
delete(existing, name)
|
|
}
|
|
appCfg.EnabledPlugins = make([]string, 0, len(existing))
|
|
for n := range existing {
|
|
appCfg.EnabledPlugins = append(appCfg.EnabledPlugins, n)
|
|
}
|
|
if err := config.SaveAppConfig(appCfg); err != nil {
|
|
return fmt.Errorf("save config: %w", err)
|
|
}
|
|
|
|
if enabled {
|
|
a.plugins.ActivatePlugin(name)
|
|
} else {
|
|
a.plugins.DeactivatePlugin(name)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetPluginPanelHTML returns the HTML panel content for a plugin.
|
|
func (a *App) GetPluginPanelHTML(pluginName string) (string, error) {
|
|
if a.plugins == nil {
|
|
return "", fmt.Errorf("plugin manager not ready")
|
|
}
|
|
for _, p := range a.plugins.Plugins() {
|
|
if p.Meta.Name != pluginName || !p.Active {
|
|
continue
|
|
}
|
|
if p.Meta.Panel == "" {
|
|
return "", nil
|
|
}
|
|
panelPath := filepath.Join(p.Dir, p.Meta.Panel)
|
|
data, err := os.ReadFile(panelPath)
|
|
if err != nil {
|
|
return "", fmt.Errorf("read panel %s: %w", p.Meta.Panel, err)
|
|
}
|
|
return string(data), nil
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
// ListSystemViewsWithPlugins returns system views + plugin sidebar items.
|
|
func (a *App) ListSystemViewsWithPlugins() []SystemViewDTO {
|
|
base := a.ListSystemViews()
|
|
if a.plugins == nil {
|
|
return base
|
|
}
|
|
|
|
appCfg, _ := config.LoadAppConfig()
|
|
enabledSet := make(map[string]bool)
|
|
if appCfg != nil {
|
|
for _, name := range appCfg.EnabledPlugins {
|
|
enabledSet[name] = true
|
|
}
|
|
}
|
|
|
|
for _, p := range a.plugins.Plugins() {
|
|
active := enabledSet[p.Meta.Name] || p.Active
|
|
if !active {
|
|
continue
|
|
}
|
|
for _, item := range p.Meta.UI.SidebarItems {
|
|
pageID := "plugin:" + p.Meta.Name + ":" + item.ID
|
|
base = append(base, SystemViewDTO{
|
|
ID: pageID,
|
|
Label: item.Label,
|
|
Icon: item.Icon,
|
|
})
|
|
}
|
|
}
|
|
return base
|
|
}
|
|
|
|
// validLuaIdent matches a safe Lua identifier segment: [a-zA-Z_][a-zA-Z0-9_]*
|
|
var validLuaIdent = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
|
|
|
|
// CallPluginFunction calls a global Lua function on an active plugin.
|
|
// The funcName can use dots: "calendar.create_event" → _G.calendar.create_event
|
|
// Only alphanumeric identifiers with underscores are allowed (no Lua injection).
|
|
// Returns JSON string or error.
|
|
func (a *App) CallPluginFunction(pluginName, funcName string, paramsJSON string) (string, error) {
|
|
if a.plugins == nil {
|
|
return "", fmt.Errorf("plugin manager not ready")
|
|
}
|
|
|
|
// Validate funcName: only [a-zA-Z0-9_.]+ allowed, each segment must be valid ident
|
|
if funcName == "" {
|
|
return "", fmt.Errorf("funcName is empty")
|
|
}
|
|
segments := strings.Split(funcName, ".")
|
|
if len(segments) > 3 {
|
|
return "", fmt.Errorf("funcName %q too deep (max 2 dots)", funcName)
|
|
}
|
|
for _, seg := range segments {
|
|
if !validLuaIdent.MatchString(seg) {
|
|
return "", fmt.Errorf("funcName %q contains invalid segment %q", funcName, seg)
|
|
}
|
|
}
|
|
|
|
for _, p := range a.plugins.Plugins() {
|
|
if p.Meta.Name != pluginName || !p.Active {
|
|
continue
|
|
}
|
|
vm := p.VM()
|
|
if vm == nil {
|
|
continue
|
|
}
|
|
|
|
// Resolve the function via _G to avoid string-based code generation
|
|
var fn lua.LValue
|
|
if len(segments) == 1 {
|
|
fn = vm.LState().GetGlobal(segments[0])
|
|
} else {
|
|
// Walk the dotted path: _G[seg1][seg2]...
|
|
tbl := vm.LState().GetGlobal(segments[0])
|
|
for i := 1; i < len(segments); i++ {
|
|
if t, ok := tbl.(*lua.LTable); ok {
|
|
tbl = t.RawGetString(segments[i])
|
|
} else {
|
|
tbl = lua.LNil
|
|
break
|
|
}
|
|
}
|
|
fn = tbl
|
|
}
|
|
|
|
if fn == lua.LNil {
|
|
return "", fmt.Errorf("function %q not found in plugin %q", funcName, pluginName)
|
|
}
|
|
if _, ok := fn.(*lua.LFunction); !ok {
|
|
return "", fmt.Errorf("%q is not a function in plugin %q", funcName, pluginName)
|
|
}
|
|
|
|
// Parse params into Lua value
|
|
luaArg, err := parseParamsToLua(vm, paramsJSON)
|
|
if err != nil {
|
|
return "", fmt.Errorf("parse params: %w", err)
|
|
}
|
|
|
|
// Call the function directly via PCall (no string-based code generation)
|
|
vm.LState().Push(fn)
|
|
if luaArg != nil {
|
|
vm.LState().Push(luaArg)
|
|
}
|
|
nargs := 0
|
|
if luaArg != nil {
|
|
nargs = 1
|
|
}
|
|
if err := vm.LState().PCall(nargs, 1, nil); err != nil {
|
|
return "", fmt.Errorf("call %s: %w", funcName, err)
|
|
}
|
|
ret := vm.LState().Get(-1)
|
|
vm.LState().Pop(1)
|
|
return ret.String(), nil
|
|
}
|
|
return "", fmt.Errorf("plugin %q not active or not found", pluginName)
|
|
}
|
|
|
|
// parseParamsToLua converts a JSON params string to a lua.LValue.
|
|
// Empty or "{}" → nil (no argument).
|
|
func parseParamsToLua(vm *plugins.LuaVM, paramsJSON string) (lua.LValue, error) {
|
|
if paramsJSON == "" || paramsJSON == "{}" {
|
|
return nil, nil
|
|
}
|
|
var params interface{}
|
|
if err := json.Unmarshal([]byte(paramsJSON), ¶ms); err != nil {
|
|
return nil, fmt.Errorf("invalid JSON params: %w", err)
|
|
}
|
|
return goToLua(vm.LState(), params), nil
|
|
}
|
|
|
|
// goToLua converts a Go interface{} to a lua.LValue.
|
|
func goToLua(L *lua.LState, v interface{}) lua.LValue {
|
|
switch val := v.(type) {
|
|
case nil:
|
|
return lua.LNil
|
|
case string:
|
|
return lua.LString(val)
|
|
case float64:
|
|
return lua.LNumber(val)
|
|
case bool:
|
|
return lua.LBool(val)
|
|
case map[string]interface{}:
|
|
tbl := L.NewTable()
|
|
for k, v := range val {
|
|
tbl.RawSetString(k, goToLua(L, v))
|
|
}
|
|
return tbl
|
|
case []interface{}:
|
|
tbl := L.NewTable()
|
|
for i, v := range val {
|
|
tbl.RawSetInt(i+1, goToLua(L, v))
|
|
}
|
|
return tbl
|
|
default:
|
|
return lua.LString(fmt.Sprintf("%v", v))
|
|
}
|
|
}
|
|
|
|
// ReloadPlugins re-scans the plugins directory and re-initializes runtimes.
|
|
func (a *App) ReloadPlugins() error {
|
|
if a.plugins == nil {
|
|
return fmt.Errorf("plugin manager not ready")
|
|
}
|
|
log.Print("[plugins] reload requested")
|
|
// Fully stop runtimes: schedulers first (they depend on VMs), then VMs
|
|
a.plugins.StopSchedulers()
|
|
a.plugins.CallShutdownHooks()
|
|
a.plugins.CloseRuntimes()
|
|
|
|
a.plugins.Discover()
|
|
|
|
appCfg, _ := config.LoadAppConfig()
|
|
a.plugins.SyncConfig(appCfg)
|
|
|
|
a.plugins.InitRuntimes()
|
|
a.plugins.CallInitHooks()
|
|
a.plugins.StartSchedulers()
|
|
log.Print("[plugins] reload complete")
|
|
return nil
|
|
}
|
|
|
|
// InstallPlugin creates plugin's database tables and defaults via on_install hook.
|
|
// Does NOT activate the plugin — use SetPluginEnabled after.
|
|
func (a *App) InstallPlugin(name string) error {
|
|
if a.plugins == nil {
|
|
return fmt.Errorf("plugin manager not ready")
|
|
}
|
|
return a.plugins.Install(name)
|
|
}
|
|
|
|
// UninstallPlugin drops plugin's database tables and cleans data via on_uninstall hook.
|
|
// Disables the plugin first if active. Does NOT delete plugin files from disk.
|
|
func (a *App) UninstallPlugin(name string) error {
|
|
if a.plugins == nil {
|
|
return fmt.Errorf("plugin manager not ready")
|
|
}
|
|
return a.plugins.Uninstall(name)
|
|
}
|