DNF90 服务端与启动器完整源码（含 GM 工具功能增强）

服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
2026-11-04 14:31:55 +08:00
commit 645b64fe21
@@ -0,0 +1,7 @@
+// Package scripthost 定义脚本运行时接入边界。
+//
+// Host 和 Program 实现必须可被并发调用，并且必须尊重传入 context。
+// 适配层应把脚本 panic、VM trap、超时和资源限额命中转换为 error；框架不把脚本崩溃视为可忽略事件。
+// Program.Execute 不得复用调用方可变输入缓冲区作为长期状态，返回的 Result 也应由实现方完成拷贝隔离。
+// Runtime 只负责脚本版本注册、预检、切换和执行；Profile 写入、事务、EventLog 和 Outbox 仍由 Go 侧可靠链路执行。
+package scripthost
@@ -0,0 +1,326 @@
+package scripthost
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync"
+
+	"longheng.io/server/internal/platform/hotreload"
+)
+
+var (
+	// ErrBadScriptRequest 表示热更脚本执行入口收到了非脚本请求。
+	ErrBadScriptRequest = errors.New("script request payload is invalid")
+
+	// ErrBadScriptResult 表示脚本 route 返回了非脚本结果。
+	ErrBadScriptResult = errors.New("script result payload is invalid")
+)
+
+// ScriptHook 是脚本版本切换过程中的预检、激活和停用扩展点。
+type ScriptHook func(context.Context, Program) error
+
+// Runtime 是逻辑脚本不停服热更的统一扩展接口。
+type Runtime interface {
+	Register(context.Context, ScriptModule) error
+	Activate(context.Context, string, string) (hotreload.Result, error)
+	Rollback(context.Context, string, string) (hotreload.Result, error)
+	Execute(context.Context, string, Request) (Result, error)
+	Snapshot() hotreload.Snapshot
+}
+
+// ScriptModule 描述一个可热更的脚本 route 版本。
+type ScriptModule struct {
+	Route      string         `json:"route"`
+	Version    string         `json:"version"`
+	Script     Script         `json:"script"`
+	Function   string         `json:"function,omitempty"`
+	Metadata   map[string]any `json:"metadata,omitempty"`
+	Preflight  ScriptHook     `json:"-"`
+	Activate   ScriptHook     `json:"-"`
+	Deactivate ScriptHook     `json:"-"`
+}
+
+// RuntimeOptions 定义脚本热更运行时的可注入依赖。
+type RuntimeOptions struct {
+	Host     Host
+	Registry *hotreload.Registry
+}
+
+// HotRuntime 把脚本宿主和 hotreload registry 组合成逻辑脚本热更入口。
+type HotRuntime struct {
+	host     Host
+	registry *hotreload.Registry
+	mu       sync.Mutex
+	bars     map[string]*hotreload.DrainBarrier
+	regLocks map[string]*sync.Mutex
+}
+
+// NewRuntime 创建可注册、激活、回滚和执行脚本版本的热更运行时。
+func NewRuntime(options RuntimeOptions) (*HotRuntime, error) {
+	if options.Host == nil {
+		return nil, ErrScriptHostRequired
+	}
+	registry := options.Registry
+	if registry == nil {
+		registry = hotreload.NewRegistry(hotreload.Options{})
+	}
+	return &HotRuntime{host: options.Host, registry: registry}, nil
+}
+
+// Register 编译脚本并把它注册成可原子切换的 route 版本。
+func (r *HotRuntime) Register(ctx context.Context, module ScriptModule) error {
+	if r == nil || r.host == nil || r.registry == nil {
+		return ErrScriptHostRequired
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	module, err := normModule(module)
+	if err != nil {
+		return err
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	program, err := r.host.Compile(ctx, module.Script)
+	if err != nil {
+		return err
+	}
+	if program == nil {
+		return ErrScriptHostRequired
+	}
+	regLock := r.regLock(module.Route)
+	regLock.Lock()
+	defer regLock.Unlock()
+	r.bar(module.Route, true)
+	_, hadActive := r.registry.ActiveVersion(module.Route)
+	hotModule := hotreload.Module{
+		Route:    module.Route,
+		Version:  module.Version,
+		Metadata: scriptMeta(module),
+		Handler:  makeHandler(module, program),
+		Preflight: func(ctx context.Context, _ hotreload.Module) error {
+			return runHook(ctx, module.Preflight, program)
+		},
+		Activate: func(ctx context.Context, _ hotreload.Module) error {
+			return runHook(ctx, module.Activate, program)
+		},
+		Deactivate: func(ctx context.Context, _ hotreload.Module) error {
+			return runHook(ctx, module.Deactivate, program)
+		},
+	}
+	if !hadActive {
+		if err := hotModule.Preflight(ctx, hotModule); err != nil {
+			return err
+		}
+		if err := hotModule.Activate(ctx, hotModule); err != nil {
+			return err
+		}
+	}
+	return r.registry.Register(hotModule)
+}
+
+// Activate 将指定 route 切到目标脚本版本。
+func (r *HotRuntime) Activate(ctx context.Context, route, version string) (hotreload.Result, error) {
+	return r.switchTo(ctx, route, version)
+}
+
+// Rollback 将指定 route 切回旧脚本版本。
+func (r *HotRuntime) Rollback(ctx context.Context, route, version string) (hotreload.Result, error) {
+	return r.switchTo(ctx, route, version)
+}
+
+// Execute 执行当前激活版本的脚本 route。
+func (r *HotRuntime) Execute(ctx context.Context, route string, request Request) (Result, error) {
+	if r == nil || r.registry == nil {
+		return Result{}, ErrScriptHostRequired
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	route = strings.TrimSpace(route)
+	if route == "" {
+		return Result{}, hotreload.ErrRouteRequired
+	}
+	barrier := r.bar(route, false)
+	if barrier != nil {
+		leave, err := barrier.EnterWhenReady(ctx)
+		if err != nil {
+			return Result{}, err
+		}
+		defer leave()
+	}
+	response, err := r.registry.Dispatch(ctx, route, request, nil)
+	if err != nil {
+		return Result{}, err
+	}
+	result, ok := response.Payload.(Result)
+	if !ok {
+		return Result{}, ErrBadScriptResult
+	}
+	return result, nil
+}
+
+// Snapshot 返回脚本热更 route 和版本快照。
+func (r *HotRuntime) Snapshot() hotreload.Snapshot {
+	if r == nil || r.registry == nil {
+		return hotreload.Snapshot{}
+	}
+	return r.registry.Snapshot()
+}
+
+func (r *HotRuntime) switchTo(ctx context.Context, route, version string) (hotreload.Result, error) {
+	if r == nil || r.registry == nil {
+		return hotreload.Result{}, ErrScriptHostRequired
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	route = strings.TrimSpace(route)
+	if route == "" {
+		return hotreload.Result{}, hotreload.ErrRouteRequired
+	}
+	barrier := r.bar(route, false)
+	if barrier != nil {
+		if err := barrier.Drain(ctx); err != nil {
+			barrier.Resume()
+			return hotreload.Result{}, err
+		}
+		defer barrier.Resume()
+	}
+	return r.registry.Activate(ctx, route, version)
+}
+
+func (r *HotRuntime) bar(route string, create bool) *hotreload.DrainBarrier {
+	if r == nil {
+		return nil
+	}
+	route = strings.TrimSpace(route)
+	if route == "" {
+		return nil
+	}
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.bars == nil {
+		if !create {
+			return nil
+		}
+		r.bars = make(map[string]*hotreload.DrainBarrier)
+	}
+	barrier := r.bars[route]
+	if barrier == nil && create {
+		barrier = hotreload.NewDrainBarrier()
+		r.bars[route] = barrier
+	}
+	return barrier
+}
+
+func (r *HotRuntime) regLock(route string) *sync.Mutex {
+	route = strings.TrimSpace(route)
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.regLocks == nil {
+		r.regLocks = make(map[string]*sync.Mutex)
+	}
+	lock := r.regLocks[route]
+	if lock == nil {
+		lock = &sync.Mutex{}
+		r.regLocks[route] = lock
+	}
+	return lock
+}
+
+func normModule(module ScriptModule) (ScriptModule, error) {
+	module.Route = strings.TrimSpace(module.Route)
+	if module.Route == "" {
+		return ScriptModule{}, hotreload.ErrRouteRequired
+	}
+	module.Version = strings.TrimSpace(module.Version)
+	if module.Version == "" {
+		return ScriptModule{}, hotreload.ErrVersionRequired
+	}
+	if err := ValidateScript(module.Script); err != nil {
+		return ScriptModule{}, err
+	}
+	module.Script.Name = strings.TrimSpace(module.Script.Name)
+	module.Script.Language = strings.TrimSpace(module.Script.Language)
+	module.Script.Metadata = copyStrMap(module.Script.Metadata)
+	module.Function = strings.TrimSpace(module.Function)
+	module.Metadata = copyAnyMap(module.Metadata)
+	return module, nil
+}
+
+func makeHandler(module ScriptModule, program Program) hotreload.Handler {
+	return func(ctx context.Context, request hotreload.Request) (hotreload.Response, error) {
+		scriptReq, ok := request.Payload.(Request)
+		if !ok {
+			return hotreload.Response{}, ErrBadScriptRequest
+		}
+		if strings.TrimSpace(scriptReq.Script) == "" {
+			scriptReq.Script = module.Script.Name
+		}
+		if strings.TrimSpace(scriptReq.Function) == "" {
+			scriptReq.Function = module.Function
+		}
+		scriptReq.Metadata = copyStrMap(scriptReq.Metadata)
+		result, err := program.Execute(ctx, scriptReq)
+		if err != nil {
+			return hotreload.Response{}, err
+		}
+		return hotreload.Response{Payload: result}, nil
+	}
+}
+
+func runHook(ctx context.Context, hook ScriptHook, program Program) error {
+	if hook == nil {
+		return nil
+	}
+	return hook(ctx, program)
+}
+
+func scriptMeta(module ScriptModule) map[string]any {
+	metadata := copyAnyMap(module.Metadata)
+	if metadata == nil {
+		metadata = make(map[string]any, 4)
+	}
+	metadata["script"] = module.Script.Name
+	metadata["version"] = module.Version
+	if module.Script.Language != "" {
+		metadata["language"] = module.Script.Language
+	}
+	if module.Function != "" {
+		metadata["function"] = module.Function
+	}
+	return metadata
+}
+
+func copyStrMap(in map[string]string) map[string]string {
+	if len(in) == 0 {
+		return nil
+	}
+	out := make(map[string]string, len(in))
+	for key, value := range in {
+		key = strings.TrimSpace(key)
+		if key == "" {
+			continue
+		}
+		out[key] = value
+	}
+	return out
+}
+
+func copyAnyMap(in map[string]any) map[string]any {
+	if len(in) == 0 {
+		return nil
+	}
+	out := make(map[string]any, len(in))
+	for key, value := range in {
+		key = strings.TrimSpace(key)
+		if key == "" {
+			continue
+		}
+		out[key] = value
+	}
+	return out
+}
@@ -0,0 +1,105 @@
+package scripthost
+
+import (
+	"context"
+	"errors"
+	"strings"
+)
+
+var (
+	// ErrScriptNameRequired 表示脚本名称为空。
+	ErrScriptNameRequired = errors.New("script name is required")
+
+	// ErrScriptSourceEmpty 表示脚本源码为空。
+	ErrScriptSourceEmpty = errors.New("script source is empty")
+
+	// ErrScriptHostRequired 表示脚本宿主或程序实现缺失。
+	ErrScriptHostRequired = errors.New("script host is required")
+)
+
+// Script 描述一份可编译的脚本源码。
+type Script struct {
+	Name     string            `json:"name"`
+	Language string            `json:"language"`
+	Source   []byte            `json:"source,omitempty"`
+	Metadata map[string]string `json:"metadata,omitempty"`
+}
+
+// Request 是脚本执行时传入宿主的最小请求。
+type Request struct {
+	Script   string            `json:"script"`
+	Function string            `json:"function,omitempty"`
+	Input    []byte            `json:"input,omitempty"`
+	Metadata map[string]string `json:"metadata,omitempty"`
+}
+
+// Result 是脚本执行后的返回结果。
+type Result struct {
+	Output   []byte            `json:"output,omitempty"`
+	Metadata map[string]string `json:"metadata,omitempty"`
+}
+
+// Program 必须可并发 Execute；脚本运行时的全局状态隔离由具体 Host 负责。
+type Program interface {
+	Execute(context.Context, Request) (Result, error)
+}
+
+// Host 编译脚本并返回可执行程序。
+// Compile 应只做编译与绑定，不应在持久化热路径里启动长生命周期 goroutine。
+type Host interface {
+	Compile(context.Context, Script) (Program, error)
+}
+
+// ProgramFunc 把普通函数适配为 Program。
+type ProgramFunc func(context.Context, Request) (Result, error)
+
+// Execute 执行适配后的脚本函数。
+func (f ProgramFunc) Execute(ctx context.Context, request Request) (Result, error) {
+	if f == nil {
+		return Result{}, ErrScriptHostRequired
+	}
+	return f(ctx, request)
+}
+
+// HostFunc 把普通函数适配为 Host。
+type HostFunc func(context.Context, Script) (Program, error)
+
+// Compile 编译脚本并返回可执行程序。
+func (f HostFunc) Compile(ctx context.Context, script Script) (Program, error) {
+	if f == nil {
+		return nil, ErrScriptHostRequired
+	}
+	return f(ctx, script)
+}
+
+// ValidateScript 校验脚本名称和源码是否满足编译前置条件。
+func ValidateScript(script Script) error {
+	if strings.TrimSpace(script.Name) == "" {
+		return ErrScriptNameRequired
+	}
+	if len(script.Source) == 0 {
+		return ErrScriptSourceEmpty
+	}
+	return nil
+}
+
+// CompileAndExecute 编译脚本并立即执行一次。
+func CompileAndExecute(ctx context.Context, host Host, script Script, request Request) (Result, error) {
+	if host == nil {
+		return Result{}, ErrScriptHostRequired
+	}
+	if err := ValidateScript(script); err != nil {
+		return Result{}, err
+	}
+	program, err := host.Compile(ctx, script)
+	if err != nil {
+		return Result{}, err
+	}
+	if program == nil {
+		return Result{}, ErrScriptHostRequired
+	}
+	if strings.TrimSpace(request.Script) == "" {
+		request.Script = script.Name
+	}
+	return program.Execute(ctx, request)
+}