package main import ( "bufio" "context" "crypto/md5" "crypto/subtle" "embed" "encoding/hex" "encoding/json" "flag" "fmt" "io" "io/fs" "net" "net/http" "os" "os/exec" "path" "path/filepath" "runtime" "strings" "syscall" "time" "unsafe" "bj_power_wms/internal/config" "bj_power_wms/internal/db" "bj_power_wms/internal/eventlog" "bj_power_wms/internal/handler" "bj_power_wms/internal/logdaily" "bj_power_wms/internal/mesclient" "bj_power_wms/internal/scanbridge" "bj_power_wms/internal/svc" "bj_power_wms/internal/tray" "golang.org/x/crypto/bcrypt" "golang.org/x/sys/windows" "bj_power_wms/ent/alert" "bj_power_wms/ent/user" "github.com/zeromicro/go-zero/core/conf" "github.com/zeromicro/go-zero/core/logx" "github.com/zeromicro/go-zero/rest" ) // 前端静态资源(Vue 构建产物,由 frontend/ npm run build 输出到 web/static)。 // 原由 bj_power_wms_client(8891) 托管并反代 API,2026-09-07 合并进主服务: // 一个 exe、一个端口(8890)同时提供页面与 API。 // //go:embed all:web/static var webFS embed.FS var configFile = flag.String("f", "etc/bj_power_wms-api.yaml", "the config file") // newStaticHandler 嵌入式静态文件:命中则直接返回;未命中的非 /api 路径 // 回退到 index.html(SPA history 路由),由浏览器端 Vue Router 接管。 func newStaticHandler(fsys embed.FS) http.Handler { sub, err := fs.Sub(fsys, "web/static") if err != nil { panic(fmt.Sprintf("嵌入静态目录不可用: %v", err)) } fileServer := http.FileServer(http.FS(sub)) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { name := strings.TrimPrefix(path.Clean(r.URL.Path), "/") if name == "" { name = "index.html" } if f, openErr := sub.Open(name); openErr == nil { f.Close() fileServer.ServeHTTP(w, r) return } r2 := r.Clone(r.Context()) r2.URL.Path = "/" fileServer.ServeHTTP(w, r2) }) } // openBrowser 调用系统默认浏览器打开 url(仅本机开发使用,服务器部署时 Web.OpenBrowser=false) func openBrowser(url string) { var cmd *exec.Cmd switch runtime.GOOS { case "windows": cmd = exec.Command("rundll32", "url.dll,FileProtocolHandler", url) case "darwin": cmd = exec.Command("open", url) default: cmd = exec.Command("xdg-open", url) } _ = cmd.Start() } // promptPassword 从终端读取一行输入(不隐藏回显,用于运维终端操作) func promptPassword(msg string) string { fmt.Print(msg) line, _ := bufio.NewReader(os.Stdin).ReadString('\n') return strings.TrimRight(line, "\r\n") } // attachCLIConsole Windows GUI 子系统(-H windowsgui 打包)默认没有控制台: // migrate/seed/reset-all 等子命令需要终端交互(管理员密码提示可见、可输入)。 // 从 cmd/PowerShell 启动 → AttachConsole(ATTACH_PARENT_PROCESS) 复用父控制台; // 双击启动(无父控制台)→ AllocConsole 弹出新控制台窗口。只补缺失的 std 句柄, // 已有控制台不重复处理,失败静默返回不阻断 CLI 流程(2026-11-11 修复,对齐 MES)。 func attachCLIConsole() { if runtime.GOOS != "windows" { return } if h, _ := windows.GetStdHandle(windows.STD_OUTPUT_HANDLE); h != 0 { var mode uint32 if gerr := windows.GetConsoleMode(h, &mode); gerr == nil { return // 已有控制台,不重复附加 } } kernel32 := windows.NewLazySystemDLL("kernel32.dll") attach := kernel32.NewProc("AttachConsole") alloc := kernel32.NewProc("AllocConsole") // ATTACH_PARENT_PROCESS = (DWORD)-1 if r, _, _ := attach.Call(^uintptr(0)); r == 0 { alloc.Call() } openConsole := func(name string, access uint32) windows.Handle { p, _ := windows.UTF16PtrFromString(name) h, err := windows.CreateFile(p, access, windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE, nil, windows.OPEN_EXISTING, 0, 0) if err != nil { return 0 } return h } // 句柄判活(2026-11-11 修复,对齐 MES):GUI 子系统从 cmd/PowerShell 启动时 std 句柄常为 // 「继承来的死管道」(GetFileType 仍报 PIPE)。 // - stdin:非控制台一律重建 CONIN$;stdout/stderr:WriteFile 0 字节探活,死管道重建 CONOUT$。 consoleStd := func(h windows.Handle) bool { var mode uint32 return h != 0 && windows.GetConsoleMode(h, &mode) == nil } rebind := func(std uint32, file **os.File, name string, conName string, access uint32, probe func(windows.Handle) bool) { h, _ := windows.GetStdHandle(std) if consoleStd(h) || (probe != nil && probe(h)) { return } ch := openConsole(conName, access) if ch == 0 { return } _ = windows.SetStdHandle(std, ch) *file = os.NewFile(uintptr(ch), name) } writeProbe := func(h windows.Handle) bool { if h == 0 { return false } var n uint32 return windows.WriteFile(h, nil, &n, nil) == nil } rebind(windows.STD_OUTPUT_HANDLE, &os.Stdout, "stdout", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ, writeProbe) rebind(windows.STD_ERROR_HANDLE, &os.Stderr, "stderr", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ, writeProbe) rebind(windows.STD_INPUT_HANDLE, &os.Stdin, "stdin", "CONIN$", windows.GENERIC_READ, nil) } // adminGate 敏感命令行操作(migrate/seed/reset-all)授权闸门(对齐 MES,2026-11-11 最终策略): // 管理员权限运行免密放行(提权即授权,零交互);非管理员走 BJ_POWER_CLI_PASSWORD 或终端输入。 func adminGate(c config.Config) bool { if runtime.GOOS == "windows" && windows.GetCurrentProcessToken().IsElevated() { logx.Infof("敏感命令 [%s] 以管理员权限运行,免密放行", flag.Arg(0)) fmt.Println("以管理员权限运行,免密执行 [" + flag.Arg(0) + "]") return true } pwd := cliPasswordArg() if pwd == "" { pwd = strings.TrimSpace(os.Getenv("BJ_POWER_CLI_PASSWORD")) } if pwd == "" { pwd = promptPassword("请输入管理员密码以执行 [" + flag.Arg(0) + "]: ") } if subtle.ConstantTimeCompare([]byte(pwd), []byte(c.Cli.AdminPassword)) != 1 { logx.Errorf("敏感命令 [%s] 因管理员密码校验失败被终止", flag.Arg(0)) fmt.Println("管理员密码不正确,已终止该操作。") return false } logx.Infof("敏感命令 [%s] 已通过管理员密码校验", flag.Arg(0)) return true } // cliPasswordArg 解析子命令后的 -p/--password 参数(Go flag 只解析子命令前的参数)。 func cliPasswordArg() string { args := flag.Args() for i := 1; i < len(args); i++ { if (args[i] == "-p" || args[i] == "--password") && i+1 < len(args) { return strings.TrimSpace(args[i+1]) } } return "" } // cliNotify 结果弹窗(MessageBox):GUI exe 在终端里控制台输出可能不可见,敏感命令结果一律弹窗。 func cliNotify(title, msg string) { if runtime.GOOS != "windows" { return } user32 := windows.NewLazySystemDLL("user32.dll") mb := user32.NewProc("MessageBoxW") t, terr := windows.UTF16PtrFromString(title) m, merr := windows.UTF16PtrFromString(msg) if terr != nil || merr != nil { return } mb.Call(0, uintptr(unsafe.Pointer(m)), uintptr(unsafe.Pointer(t)), 0x40) // MB_OK | MB_ICONINFORMATION } // cliNotifyError 失败弹窗(红叉图标) func cliNotifyError(title, msg string) { if runtime.GOOS != "windows" { return } user32 := windows.NewLazySystemDLL("user32.dll") mb := user32.NewProc("MessageBoxW") t, terr := windows.UTF16PtrFromString(title) m, merr := windows.UTF16PtrFromString(msg) if terr != nil || merr != nil { return } mb.Call(0, uintptr(unsafe.Pointer(m)), uintptr(unsafe.Pointer(t)), 0x10) // MB_ICONERROR } // dbConf 从服务配置构造数据库连接配置 func dbConf(c config.Config) db.DatabaseConf { return db.DatabaseConf{ Host: c.Postgres.Host, Port: c.Postgres.Port, User: c.Postgres.User, Password: c.Postgres.Password, Dbname: c.Postgres.DBName, } } // autoRegisterShortcuts 管理员运行 exe 时自动注册开机自启 + 桌面快捷方式(2026-11-11 拍板): // WMS 依赖系统托盘与浏览器会话,不注册为 Windows 服务,走「公共启动文件夹 + 公共桌面」。 // 幂等:快捷方式已存在则跳过;非管理员跳过并提示,正常启动不影响业务。 func autoRegisterShortcuts(name, arguments string) { if runtime.GOOS != "windows" { return } if !windows.GetCurrentProcessToken().IsElevated() { fmt.Println("当前非管理员权限运行,跳过开机自启/桌面快捷方式注册(如需自启,请以管理员身份运行一次本程序)。") logx.Infof("非管理员运行,跳过自启动注册") return } exe, err := os.Executable() if err != nil { logx.Errorf("获取 exe 路径失败,跳过自启动注册: %v", err) return } if realPath, rerr := filepath.EvalSymlinks(exe); rerr == nil { exe = realPath } workDir := filepath.Dir(exe) startupDir := filepath.Join(os.Getenv("ProgramData"), "Microsoft", "Windows", "Start Menu", "Programs", "StartUp") desktopDir := filepath.Join(os.Getenv("PUBLIC"), "Desktop") targets := map[string]string{ filepath.Join(startupDir, name+".lnk"): "开机自启快捷方式", filepath.Join(desktopDir, name+".lnk"): "桌面快捷方式", } for lnk, kind := range targets { if _, err := os.Stat(lnk); err == nil { logx.Infof("%s 已存在,跳过重复创建:%s", kind, lnk) continue } if err := createShortcut(lnk, exe, arguments, workDir); err != nil { logx.Errorf("创建%s失败 %s: %v", kind, lnk, err) continue } logx.Infof("已创建%s:%s → %s %s", kind, lnk, exe, arguments) } } // createShortcut 用 PowerShell(WScript.Shell COM)创建 .lnk 快捷方式(不引第三方依赖)。 // HideWindow 避免从 GUI 程序拉起 powershell 时闪黑框。 func createShortcut(linkPath, targetPath, arguments, workDir string) error { script := fmt.Sprintf( `$s=(New-Object -ComObject WScript.Shell).CreateShortcut('%s'); $s.TargetPath='%s'; $s.Arguments='%s'; $s.WorkingDirectory='%s'; $s.Save()`, linkPath, targetPath, arguments, workDir) cmd := exec.Command("powershell", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script) cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true} out, err := cmd.CombinedOutput() if err != nil { return fmt.Errorf("%v: %s", err, strings.TrimSpace(string(out))) } return nil } // ==================== 进程守护(2026-11-11 拍板:三端 exe 常驻存活) ==================== // 双进程互守(同一 exe 自举):guardian(隐形监督进程)+ worker(业务进程)。 // - 启动先抢 Local\BJP_WMS_GUARDIAN 互斥体:抢到=guardian;抢不到=worker; // - worker 持 Local\BJP_WMS_WORKER 互斥体(防重复实例),每 5s TCP 探活本机端口, // 探活成功才写心跳文件 %TEMP%\bj_power_wms.guard.json(pid/ts/listening); // - guardian:worker 退出码 0(托盘主动退出)→ 跟随退出;非 0(崩溃)→ 3s 后重拉; // 心跳过期 30s(卡死)→ 校验进程映像后杀掉重拉;连续 5 次秒退 → 退避 60s; // - worker 每 10s 检查 guardian 互斥体:消失 → 拉起新 guardian 继续监视自己(收养模式)。 const ( guardMutexName = `Local\BJP_WMS_GUARDIAN` workerMutexName = `Local\BJP_WMS_WORKER` guardHeartbeatTTL = 30 * time.Second guardSpawnGrace = 90 * time.Second ) func exePathGuard() string { exe, err := os.Executable() if err != nil { return os.Args[0] } if rp, rerr := filepath.EvalSymlinks(exe); rerr == nil { exe = rp } return exe } func createOwnedMutex(name string) (windows.Handle, bool) { h, err := windows.CreateMutex(nil, false, windows.StringToUTF16Ptr(name)) if h == 0 { return 0, false } return h, err == nil // 已存在时 err=ERROR_ALREADY_EXISTS } func mutexExists(name string) bool { h, err := windows.OpenMutex(windows.SYNCHRONIZE, false, windows.StringToUTF16Ptr(name)) if err == nil { windows.CloseHandle(h) return true } return false } type guardInfo struct { PID int `json:"pid"` TS time.Time `json:"ts"` Listening bool `json:"listening"` } func guardHeartbeatFile() string { return filepath.Join(os.TempDir(), "bj_power_wms.guard.json") } func readGuardInfo() (guardInfo, bool) { var gi guardInfo data, err := os.ReadFile(guardHeartbeatFile()) if err != nil || json.Unmarshal(data, &gi) != nil { return gi, false } return gi, true } func guardianLog(format string, args ...any) { f, err := os.OpenFile(filepath.Join(os.TempDir(), "bj_power_wms.guardian.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644) if err != nil { return } defer f.Close() fmt.Fprintf(f, time.Now().Format("2006-01-02 15:04:05 ")+"guardian: "+fmt.Sprintf(format, args...)+"\n") } // guardianHeartbeat worker 心跳:每 5s TCP 探活本机端口,成功才写心跳文件。 func guardianHeartbeat(port int) { for { listening := false if conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 3*time.Second); err == nil { conn.Close() listening = true } if data, err := json.Marshal(guardInfo{PID: os.Getpid(), TS: time.Now(), Listening: listening}); err == nil { _ = os.WriteFile(guardHeartbeatFile(), data, 0644) } time.Sleep(5 * time.Second) } } // workerWatchGuardian worker 监督 guardian:guardian 崩溃 → 拉起新 guardian 继续监视自己。 func workerWatchGuardian(exe string) { for { time.Sleep(10 * time.Second) if mutexExists(guardMutexName) { continue } guardianLog("guardian 消失,worker(%d) 重新拉起监督进程", os.Getpid()) cmd := exec.Command(exe, os.Args[1:]...) cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true} if err := cmd.Start(); err == nil { time.Sleep(15 * time.Second) // 等新 guardian 就位(收养模式),防重复拉起 } } } // killWorker 按 PID 杀 worker;先校验进程映像确为本 exe(防 PID 复用误杀)。 func killWorker(pid int, expectExe string) { if pid <= 0 { return } h, err := windows.OpenProcess(windows.PROCESS_TERMINATE|windows.SYNCHRONIZE| windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid)) if err != nil { return } defer windows.CloseHandle(h) buf := make([]uint16, 32768) size := uint32(len(buf)) if err := windows.QueryFullProcessImageName(h, 0, &buf[0], &size); err != nil { return } if !strings.EqualFold(filepath.Base(windows.UTF16ToString(buf[:size])), filepath.Base(expectExe)) { return } windows.TerminateProcess(h, 1) } // supervise 拉起 worker 子进程并盯防:正常退出返回退出码;心跳异常则杀掉。 func supervise(exe string) (int, time.Duration) { start := time.Now() cmd := exec.Command(exe, os.Args[1:]...) if err := cmd.Start(); err != nil { guardianLog("拉起 worker 失败: %v", err) return -1, 0 } done := make(chan int, 1) go func() { _ = cmd.Wait() if cmd.ProcessState != nil { done <- cmd.ProcessState.ExitCode() } else { done <- -1 } }() ticker := time.NewTicker(5 * time.Second) defer ticker.Stop() for { select { case code := <-done: return code, time.Since(start) case <-ticker.C: gi, ok := readGuardInfo() if !ok { continue } if (gi.Listening && time.Since(gi.TS) > guardHeartbeatTTL) || (!gi.Listening && time.Since(start) > guardSpawnGrace) { guardianLog("worker(%d) 心跳异常(listening=%v,距上次心跳 %v),杀掉重拉", gi.PID, gi.Listening, time.Since(gi.TS).Round(time.Second)) killWorker(gi.PID, exe) } } } } // guardianLoop guardian 主循环。 func guardianLoop(exe string) { guardianLog("guardian 启动 pid=%d args=%v", os.Getpid(), os.Args[1:]) failStreak := 0 for { if mutexExists(workerMutexName) { // 收养模式:worker 已在运行(worker 检测到 guardian 死亡后拉起了本进程) if gi, ok := readGuardInfo(); ok && gi.Listening && time.Since(gi.TS) > guardHeartbeatTTL { guardianLog("收养模式:worker(%d) 心跳过期,杀掉重拉", gi.PID) killWorker(gi.PID, exe) } time.Sleep(3 * time.Second) continue } if failStreak >= 5 { guardianLog("连续 %d 次 10s 内秒退(多为配置/环境错误),退避 60s 后继续尝试", failStreak) time.Sleep(60 * time.Second) failStreak = 0 } code, lived := supervise(exe) if code == 0 { guardianLog("worker 主动退出(code=0),guardian 跟随退出") return } if lived >= time.Minute { failStreak = 0 } else { failStreak++ } guardianLog("worker 异常退出(code=%d,存活 %v),3s 后重拉(failStreak=%d)", code, lived.Round(time.Second), failStreak) time.Sleep(3 * time.Second) } } // runGuarded 进程守护入口:决定本进程是 guardian 还是 worker。 func runGuarded(runWorker func(), port int) { if runtime.GOOS != "windows" { runWorker() return } exe := exePathGuard() if gm, owned := createOwnedMutex(guardMutexName); owned { _ = gm guardianLoop(exe) return } else { // 关键:未抢到 guardian 身份必须立即关闭观察句柄,否则 worker 会一直持有 // guardian 互斥体对象,guardian 死后自愈检测失效(2026-11-11 实测踩坑,对齐 MES)。 windows.CloseHandle(gm) } wm, workerOwned := createOwnedMutex(workerMutexName) if !workerOwned { return // 已有 worker 在运行,静默退出防重复实例 } _ = wm go workerWatchGuardian(exe) go guardianHeartbeat(port) guardianLog("worker 启动 pid=%d", os.Getpid()) runWorker() } // runMigrate 仅建表/补列(只增,不删任何数据) func runMigrate(c config.Config) error { dbc := dbConf(c) if err := db.EnsureDB(dbc); err != nil { logx.Errorf("ensure database failed: %v", err) return fmt.Errorf("准备数据库失败:%v", err) } client := db.MustNewDB(dbc) defer client.Close() if err := db.AutoMigrate(client); err != nil { logx.Errorf("migrate failed: %v", err) return fmt.Errorf("结构迁移失败:%v", err) } fmt.Println("migrate: 数据库结构迁移成功(只增/补列,未删除任何数据)。") return nil } // runSeed 对齐基础主数据 + 权限角色(不删数据;表不存在则先建) func runSeed(c config.Config) error { dbc := dbConf(c) if err := db.EnsureDB(dbc); err != nil { logx.Errorf("ensure database failed: %v", err) return fmt.Errorf("准备数据库失败:%v", err) } client := db.MustNewDB(dbc) defer client.Close() if err := db.AutoMigrate(client); err != nil { logx.Errorf("seed migrate failed: %v", err) return fmt.Errorf("结构迁移失败:%v", err) } if err := db.SeedIfEmpty(client); err != nil { logx.Errorf("seed failed: %v", err) return fmt.Errorf("写入基础数据失败:%v", err) } svcCtx := &svc.ServiceContext{EntClient: client, EventLog: eventlog.NewWriter(client)} p, r, b := handler.SeedRBAC(svcCtx, "system") // 与 MES 对齐(2026-11-11):生产已有库的 admin 密码失忆时,跑 seed 即可重置回 // admin/123456——只重置 admin 账号本身,不动其他用户与任何业务数据(对齐 MES seed.go:79-87)。 adminHash, _ := bcrypt.GenerateFromPassword([]byte("123456"), bcrypt.DefaultCost) if n, err := client.User.Update().Where(user.Username("admin")).SetPassword(string(adminHash)).Save(context.Background()); err != nil { logx.Errorf("重置 admin 密码失败: %v", err) } else if n > 0 { fmt.Println("seed: 已重置 admin 账号密码为 123456(仅 admin 账号,不动业务数据)。") } logx.Infof("seed: 基础数据与权限已对齐(新增权限 %d、角色 %d、绑定用户 %d);管理员 admin/123456", p, r, b) fmt.Printf("seed: 基础数据与权限已对齐(新增权限 %d、角色 %d、绑定用户 %d);管理员 admin/123456。\n", p, r, b) return nil } // runResetAll 清空并重建全部表 + 重灌全部种子(基础主数据 + 权限角色)。此操作不可恢复! func runResetAll(c config.Config) error { dbc := dbConf(c) if err := db.EnsureDB(dbc); err != nil { logx.Errorf("ensure database failed: %v", err) return fmt.Errorf("准备数据库失败:%v", err) } if err := db.DropAllTables(dbc); err != nil { logx.Errorf("reset-all drop failed: %v", err) return fmt.Errorf("删表失败:%v", err) } client := db.MustNewDB(dbc) defer client.Close() if err := db.AutoMigrate(client); err != nil { logx.Errorf("reset-all migrate failed: %v", err) return fmt.Errorf("重建表失败:%v", err) } if err := db.SeedIfEmpty(client); err != nil { logx.Errorf("reset-all seed failed: %v", err) return fmt.Errorf("写入基础数据失败:%v", err) } svcCtx := &svc.ServiceContext{EntClient: client, EventLog: eventlog.NewWriter(client)} p, r, b := handler.SeedRBAC(svcCtx, "system") logx.Infof("reset-all 完成:新增权限 %d、角色 %d、绑定用户 %d", p, r, b) fmt.Println("reset-all: 已清空并重建全部表,写入基础主数据与权限(管理员 admin/123456)。") return nil } // logRuntimeBinaryFingerprint 在启动早期打印当前运行 EXE 的指纹(真实路径/大小/MD5/修改时间), // 走本项目 logx(go-zero)落盘,与业务日志同文件,便于生产机直接翻日志核对运行版本。 // 任何环节失败仅记错误日志并继续,绝不中断启动。 func logRuntimeBinaryFingerprint() { exePath, err := os.Executable() if err != nil { logx.Errorf("svc: runtime binary fingerprint skipped: os.Executable failed: %v", err) return } realPath, err := filepath.EvalSymlinks(exePath) if err != nil { // 解析软链接失败:降级用原始路径,仅记日志不影响启动 logx.Errorf("svc: runtime binary fingerprint: EvalSymlinks failed, fallback to raw path: %v", err) realPath = exePath } info, err := os.Stat(realPath) if err != nil { logx.Errorf("svc: runtime binary fingerprint skipped: os.Stat failed: %v", err) return } f, err := os.Open(realPath) if err != nil { logx.Errorf("svc: runtime binary fingerprint skipped: open failed: %v", err) return } defer f.Close() h := md5.New() if _, err := io.Copy(h, f); err != nil { logx.Errorf("svc: runtime binary fingerprint skipped: read failed: %v", err) return } logx.Infof("svc: runtime binary fingerprint path=%s size=%d md5=%s modTime=%s", realPath, info.Size(), hex.EncodeToString(h.Sum(nil)), info.ModTime().Format("2006-01-02 15:04:05")) } func main() { flag.Parse() var c config.Config conf.MustLoad(*configFile, &c) // 日志按天存储:logs/bj_power_wms-2026-01-02.log,保留 30 天 if c.Log.Mode == "file" { logx.SetUp(c.Log) w := logdaily.New(c.Log.Path, c.Name, 30) defer w.Close() logx.SetWriter(logx.NewWriter(w)) } // 启动指纹:打印当前 EXE 真实路径/大小/MD5/修改时间,便于核对运行版本 logRuntimeBinaryFingerprint() // 命令行子命令:DDL/删库/种子等敏感操作一律显式触发 + 管理员密码门禁, // 绝不随服务启动自动执行(对齐 MES:migrate / seed / reset-all / serve)。 // GUI 子系统打包(-H windowsgui)无控制台:CLI 子命令先补控制台(见 attachCLIConsole)。 switch flag.Arg(0) { case "migrate", "seed", "reset-all": attachCLIConsole() } switch cmd := flag.Arg(0); cmd { case "reset-all": fmt.Println("reset-all: 即将清空并重建 WMS 全部表,此操作不可恢复!") if !adminGate(c) { cliNotifyError("reset-all 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_wms.exe reset-all -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD") os.Exit(1) } if err := runResetAll(c); err != nil { cliNotifyError("reset-all 失败", err.Error()) os.Exit(1) } cliNotify("reset-all 完成", "已清空并重建全部表,已写入基础主数据。\n管理员账号:admin / 123456") return case "seed": if !adminGate(c) { cliNotifyError("seed 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_wms.exe seed -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD") os.Exit(1) } if err := runSeed(c); err != nil { cliNotifyError("seed 失败", err.Error()) os.Exit(1) } cliNotify("seed 完成", "基础数据与权限已对齐;admin 密码已重置为 123456。") return case "migrate": if !adminGate(c) { cliNotifyError("migrate 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_wms.exe migrate -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD") os.Exit(1) } if err := runMigrate(c); err != nil { cliNotifyError("migrate 失败", err.Error()) os.Exit(1) } cliNotify("migrate 完成", "数据库结构迁移成功(只增/补列,未删除任何数据)。") return case "", "serve": // 正常启动服务:管理员运行时先自注册开机自启 + 桌面快捷方式(见 autoRegisterShortcuts) autoRegisterShortcuts("BJ Power WMS", "serve") // 进程守护(2026-11-11 拍板):guardian+worker 双进程互守,崩溃/卡死自动拉起 runGuarded(func() { runServeWMS(c) }, c.Port) return default: fmt.Println("未知命令: " + cmd + ";可用命令: migrate / seed / reset-all / serve") os.Exit(1) } } // runServeWMS 启动 WMS 服务 + 托盘(由 runGuarded 的 worker 调用)。 func runServeWMS(c config.Config) { staticHandler := newStaticHandler(webFS) // 兜底路由:已注册的 /api/* 走正常匹配;未注册的非 /api 路径走嵌入式静态资源 //(/api 下未注册的路径仍返回 404,不回退页面) notFound := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if strings.HasPrefix(r.URL.Path, "/api/") || r.URL.Path == "/api" { http.NotFound(w, r) return } staticHandler.ServeHTTP(w, r) }) server := rest.MustNewServer(c.RestConf, rest.WithNotFoundHandler(notFound)) defer server.Stop() ctx := svc.NewServiceContext(c) // MES 通讯失败预警(2026-11-16):WMS→MES 传输层失败(连不上/超时)触发, // 10 分钟窗口去重防轮询风暴;HTTP 业务错误(服务在但拒绝)不算通讯异常、不触发。 mesclient.FailHook = func(hookCtx context.Context, method, url string, hookErr error) { fc, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() since := time.Now().Add(-10 * time.Minute) cnt, cerr := ctx.EntClient.Alert.Query().Where( alert.RuleCodeEQ("mes_unreachable"), alert.StatusEQ("unread"), alert.TargetEQ("MES"), alert.CreatedAtGTE(since.Unix()), ).Count(fc) if cerr == nil && cnt > 0 { return } _, aerr := ctx.EntClient.Alert.Create(). SetRuleCode("mes_unreachable").SetLevel("warning").SetTarget("MES"). SetTitle("MES 通讯失败:" + hookErr.Error()). SetContent(fmt.Sprintf("WMS→MES %s %s(%v),备料回写/工单查询/成品反查将失败,请检查 MES 服务。", method, url, hookErr)). SetStatus("unread").Save(fc) if aerr != nil { logx.Errorf("MES 通讯失败落预警异常: %v", aerr) } } // 扫码中间件(键盘 HID 注入):Enable=true 时随 WMS 启动监听 7757,接收网络型扫码枪推送并模拟键盘注入当前光标窗口。 // 7757 被占用时仅记日志、不影响主程序(与 MES 同机同开时谁先启动谁监听,后到的只记日志)。 if c.Scanner.Enabled { go func() { if err := scanbridge.Start(context.Background(), scanbridge.Options{}); err != nil { logx.Errorf("扫码中间件启动失败(不影响主程序): %v", err) } }() } handler.RegisterHandlers(server, ctx) // 磁盘空间监控:每天 07:00 检测附件根目录剩余空间(<20% 告警、<10% 提示清理) handler.StartDiskMonitor(ctx) // 预警中心扫描器:立即跑一次,之后每 5 分钟一轮(后台协程,仅启动一次) handler.StartAlertScanner(ctx) fmt.Printf("Starting bj_power_wms server at %s:%d...\n", c.Host, c.Port) logx.Infof("Starting bj_power_wms server at %s:%d...", c.Host, c.Port) // 服务起来后自动打开浏览器访问前端(本机开发便利;Web.OpenBrowser=false 关闭) if c.Web.OpenBrowser { go func() { time.Sleep(time.Second) host := c.Host if host == "0.0.0.0" || host == "" { host = "127.0.0.1" } openBrowser(fmt.Sprintf("http://%s:%d", host, c.Port)) }() } // HTTP 服务放到 goroutine;系统托盘必须占住主 goroutine(Windows 消息循环要求)。 go func() { server.Start() }() runtime.LockOSThread() tray.Run("WMS 仓储管理", fmt.Sprintf("WMS 仓储管理 · 端口 %d", c.Port), fmt.Sprintf("http://127.0.0.1:%d/", c.Port), func() { server.Stop() os.Exit(0) }) }