@yufengtadian/freedom-cli 1.12.16 → 1.12.18

package/templates/go/pkg/freedom/tray_windows.go

@@ -0,0 +1,506 @@
+//go:build windows
+
+package freedom
+
+// 系统托盘（Shell_NotifyIcon）与原生菜单栏（HMENU）。
+//
+// 托盘通过一个隐藏消息窗口接收回调消息（WM_APP+1），菜单项点击经 WM_COMMAND
+// 分发，统一通过 App.Emit 推送到前端（freedom.tray.on('click'/'menu', ...)）。
+// 原生菜单栏通过 SetMenu 挂到主窗口，同样经 WM_COMMAND 回调。
+//
+// 与主窗口同一 UI 线程创建，消息由同一消息泵派发，无需额外线程。
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+// ---- 常量 ----
+
+const (
+	wmApp        = 0x8000 // WM_APP
+	wmCommand    = 0x0111
+	wmLButtonUp  = 0x0202
+	wmLButtonDbl = 0x0203
+	wmRButtonUp  = 0x0205
+	wmNull       = 0x0000
+
+	nimAdd    = 0x00000000
+	nimModify = 0x00000001
+	nimDelete = 0x00000002
+
+	nifMessage = 0x00000001
+	nifIcon    = 0x00000002
+	nifTip     = 0x00000004
+
+	tpmRightButton = 0x00000002
+	tpmLeftAlign   = 0x00000000
+
+	mfString    = 0x00000000
+	mfSeparator = 0x00000800
+	mfChecked   = 0x00000008
+	mfGrayed    = 0x00000001
+	mfEnabled   = 0x00000000
+	mfPopup     = 0x00000010
+	mfByPosition = 0x00000400
+)
+
+var (
+	shell32              = syscall.NewLazyDLL("shell32.dll")
+	procShellNotifyIconW = shell32.NewProc("Shell_NotifyIconW")
+
+	procRegisterClassExW   = user32win.NewProc("RegisterClassExW")
+	procCreateWindowExW    = user32win.NewProc("CreateWindowExW")
+	procDefWindowProcW     = user32win.NewProc("DefWindowProcW")
+	procCreatePopupMenu    = user32win.NewProc("CreatePopupMenu")
+	procCreateMenu         = user32win.NewProc("CreateMenu")
+	procAppendMenuW        = user32win.NewProc("AppendMenuW")
+	procInsertMenuW        = user32win.NewProc("InsertMenuW")
+	procDestroyMenu        = user32win.NewProc("DestroyMenu")
+	procTrackPopupMenu     = user32win.NewProc("TrackPopupMenu")
+	procGetCursorPos       = user32win.NewProc("GetCursorPos")
+	procSetForegroundWindow = user32win.NewProc("SetForegroundWindow")
+	procSetMenu            = user32win.NewProc("SetMenu")
+	procDrawMenuBar        = user32win.NewProc("DrawMenuBar")
+)
+
+// ---- 结构 ----
+
+type point struct {
+	X, Y int32
+}
+
+type wndClassExW struct {
+	CbSize        uint32
+	Style         uint32
+	LpfnWndProc   uintptr
+	CbClsExtra    int32
+	CbWndExtra    int32
+	HInstance     uintptr
+	HIcon         uintptr
+	HCursor       uintptr
+	HbrBackground uintptr
+	LpszMenuName  *uint16
+	LpszClassName *uint16
+	HIconSm       uintptr
+}
+
+// notifyIconDataW 对应 NOTIFYICONDATAW（amd64 布局，cbSize=984）。
+type notifyIconDataW struct {
+	CbSize           uint32
+	_                uint32 // 对齐填充
+	HWnd             uintptr
+	UID              uint32
+	UFlags           uint32
+	UCallbackMessage uint32
+	HIcon            uintptr
+	SzTip            [128]uint16
+	DwState          uint32
+	DwStateMask      uint32
+	SzInfo           [256]uint16
+	UVersion         uint32
+	SzInfoTitle      [64]uint16
+	DwInfoFlags      uint32
+	GuidItem         [16]byte
+	HBalloonIcon     uintptr
+}
+
+// menuItem 描述一个托盘/菜单栏条目（JSON 透传）。
+type menuItem struct {
+	ID      string     `json:"id"`
+	Label   string     `json:"label"`
+	Type    string     `json:"type"`    // "item"（默认）/ "separator" / "submenu"
+	Enabled *bool      `json:"enabled"` // nil=默认启用
+	Checked *bool      `json:"checked"`
+	Submenu []menuItem `json:"submenu"`
+}
+
+// trayState 保存当前托盘实例（单窗口框架内为单例）。
+type trayState struct {
+	mu      sync.Mutex
+	hwnd    uintptr           // 隐藏消息窗口
+	menu    uintptr           // 右键 popup 菜单
+	menuBar uintptr           // 原生菜单栏 HMENU
+	items   map[uint32]string // menu id -> 前端 id
+	nextID  uint32
+	emit    func(event string, data interface{})
+	icon    uintptr // 当前托盘图标 HICON
+}
+
+var (
+	trayProcMu    sync.Mutex
+	trayStateInst *trayState
+	trayWndProcCB uintptr
+)
+
+// trayProcCallback 是隐藏窗口的 WndProc（Go 回调，经 syscall.NewCallback 注册）。
+// 由 RegisterClassEx 注册到系统，消息泵在 UI 线程派发。
+func trayProcCallback(hwnd uintptr, msg uint32, wParam, lParam uintptr) uintptr {
+	ts := trayStateInst
+	if ts == nil {
+		r, _, _ := procDefWindowProcW.Call(hwnd, uintptr(msg), wParam, lParam)
+		return r
+	}
+	switch msg {
+	case uint32(wmApp) + 1: // uCallbackMessage
+		switch lParam & 0xFFFF {
+		case wmLButtonUp:
+			ts.emit("tray:click", map[string]interface{}{"button": "left"})
+		case wmLButtonDbl:
+			ts.emit("tray:double-click", map[string]interface{}{"button": "left"})
+		case wmRButtonUp:
+			trayShowMenu(ts)
+		}
+	case uint32(wmCommand):
+		id := uint32(wParam & 0xFFFF)
+		ts.mu.Lock()
+		label, ok := ts.items[id]
+		ts.mu.Unlock()
+		if ok {
+			ts.emit("tray:menu", map[string]interface{}{"id": label})
+		}
+	}
+	r, _, _ := procDefWindowProcW.Call(hwnd, uintptr(msg), wParam, lParam)
+	return r
+}
+
+// ensureTrayWindow 创建隐藏消息窗口（仅一次）。
+func ensureTrayWindow(a *App) (*trayState, error) {
+	trayProcMu.Lock()
+	defer trayProcMu.Unlock()
+	if trayStateInst != nil {
+		return trayStateInst, nil
+	}
+	className, _ := syscall.UTF16PtrFromString("FreedomTrayWnd")
+	if trayWndProcCB == 0 {
+		trayWndProcCB = syscall.NewCallback(trayProcCallback)
+	}
+	hInst := uintptr(0)
+	if m, _, _ := procGetModuleHandle.Call(0); m != 0 {
+		hInst = m
+	}
+	wc := wndClassExW{
+		CbSize:        uint32(unsafe.Sizeof(wndClassExW{})),
+		LpfnWndProc:   trayWndProcCB,
+		HInstance:     hInst,
+		LpszClassName: className,
+	}
+	if r, _, _ := procRegisterClassExW.Call(uintptr(unsafe.Pointer(&wc))); r == 0 {
+		// 可能已注册，继续尝试。
+	}
+	ts := &trayState{
+		items:  map[uint32]string{},
+		nextID: 1,
+		emit:   a.Emit,
+	}
+	hwnd, _, _ := procCreateWindowExW.Call(
+		0,
+		uintptr(unsafe.Pointer(className)),
+		uintptr(unsafe.Pointer(className)),
+		0,
+		0, 0, 0, 0,
+		0, 0, hInst, 0,
+	)
+	if hwnd == 0 {
+		return nil, fmt.Errorf("tray: 创建隐藏窗口失败")
+	}
+	ts.hwnd = hwnd
+	trayStateInst = ts
+	return ts, nil
+}
+
+// traySetIcon 创建或更新托盘图标。
+func traySetIcon(ts *trayState, iconData []byte, tooltip string) error {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	// 释放旧图标。
+	if ts.icon != 0 {
+		procDestroyIcon.Call(ts.icon)
+		ts.icon = 0
+	}
+	nid := &notifyIconDataW{
+		CbSize:           uint32(unsafe.Sizeof(notifyIconDataW{})),
+		HWnd:             ts.hwnd,
+		UID:              1,
+		UFlags:           nifMessage | nifIcon | nifTip,
+		UCallbackMessage: wmApp + 1,
+	}
+	if len(iconData) > 0 {
+		ic := hiconFromPNG(iconData)
+		if ic == 0 {
+			return fmt.Errorf("tray: 无法从图标数据创建 HICON")
+		}
+		nid.HIcon = ic
+		ts.icon = ic
+	} else {
+		// 无图标数据：使用 exe 内嵌图标。
+		cx, _, _ := procGetSystemMetrics.Call(smCXSmall)
+		cy, _, _ := procGetSystemMetrics.Call(smCYSmall)
+		if ic := loadExeIcon(cx, cy); ic != 0 {
+			nid.HIcon = ic
+			ts.icon = ic
+		}
+	}
+	if tooltip != "" {
+		tp, _ := syscall.UTF16FromString(tooltip)
+		copy(nid.SzTip[:], tp[:min(len(tp), 127)])
+	}
+	// 首次 NIM_ADD，之后 NIM_MODIFY。
+	if ts.hwnd == 0 || !trayIconAdded {
+		trayIconAdded = true
+		r, _, _ := procShellNotifyIconW.Call(nimAdd, uintptr(unsafe.Pointer(nid)))
+		if r == 0 {
+			return fmt.Errorf("tray: Shell_NotifyIcon(NIM_ADD) 失败")
+		}
+	} else {
+		r, _, _ := procShellNotifyIconW.Call(nimModify, uintptr(unsafe.Pointer(nid)))
+		if r == 0 {
+			return fmt.Errorf("tray: Shell_NotifyIcon(NIM_MODIFY) 失败")
+		}
+	}
+	return nil
+}
+
+var trayIconAdded bool
+
+// trayShowMenu 在鼠标位置弹出右键菜单。
+func trayShowMenu(ts *trayState) {
+	if ts == nil || ts.menu == 0 {
+		return
+	}
+	var pt point
+	procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt)))
+	procSetForegroundWindow.Call(ts.hwnd)
+	procTrackPopupMenu.Call(
+		ts.menu, tpmRightButton|tpmLeftAlign,
+		uintptr(pt.X), uintptr(pt.Y), 0, ts.hwnd, 0,
+	)
+	procPostMessage.Call(ts.hwnd, wmNull, 0, 0)
+}
+
+// buildMenu 递归构建 HMENU（用于托盘右键与菜单栏子菜单）。
+// 返回菜单句柄与 id 映射（追加到 ts.items）。
+func buildMenu(ts *trayState, items []menuItem) uintptr {
+	hMenu, _, _ := procCreatePopupMenu.Call()
+	if hMenu == 0 {
+		return 0
+	}
+	appendMenuItems(ts, hMenu, items, false)
+	return hMenu
+}
+
+// appendMenuItems 把条目追加到指定菜单。
+func appendMenuItems(ts *trayState, hMenu uintptr, items []menuItem, isMenuBar bool) {
+	for i, it := range items {
+		if it.Type == "separator" {
+			procAppendMenuW.Call(hMenu, mfSeparator, 0, 0)
+			continue
+		}
+		if it.Type == "submenu" || (isMenuBar && len(it.Submenu) > 0) {
+			sub := buildMenu(ts, it.Submenu)
+			if sub == 0 {
+				continue
+			}
+			label, _ := syscall.UTF16PtrFromString(it.Label)
+			procAppendMenuW.Call(hMenu, mfPopup|mfEnabled, sub, uintptr(unsafe.Pointer(label)))
+			continue
+		}
+		var flags uintptr = mfString | mfEnabled
+		if it.Checked != nil && *it.Checked {
+			flags |= mfChecked
+		}
+		if it.Enabled != nil && !*it.Enabled {
+			flags |= mfGrayed
+		}
+		id := ts.nextID
+		ts.nextID++
+		ts.mu.Lock()
+		ts.items[id] = it.ID
+		ts.mu.Unlock()
+		label, _ := syscall.UTF16PtrFromString(it.Label)
+		if isMenuBar && i == 0 {
+			// 菜单栏首个条目用 MF_BYPOSITION 占位（顶层菜单由 SetMenu 接管）。
+		}
+		procAppendMenuW.Call(hMenu, flags, uintptr(id), uintptr(unsafe.Pointer(label)))
+	}
+}
+
+// traySetMenu 设置托盘右键菜单（整体替换）。
+func traySetMenu(ts *trayState, items []menuItem) {
+	ts.mu.Lock()
+	old := ts.menu
+	ts.menu = 0
+	ts.mu.Unlock()
+	if old != 0 {
+		procDestroyMenu.Call(old)
+	}
+	if len(items) == 0 {
+		return
+	}
+	h := buildMenu(ts, items)
+	ts.mu.Lock()
+	ts.menu = h
+	ts.mu.Unlock()
+}
+
+// menuBarSet 设置主窗口原生菜单栏（整体替换）。
+func menuBarSet(hwnd uintptr, ts *trayState, items []menuItem) {
+	ts.mu.Lock()
+	old := ts.menuBar
+	ts.menuBar = 0
+	ts.mu.Unlock()
+	if old != 0 {
+		procDestroyMenu.Call(old)
+	}
+	if len(items) == 0 {
+		procSetMenu.Call(hwnd, 0)
+		procDrawMenuBar.Call(hwnd)
+		return
+	}
+	hBar, _, _ := procCreateMenu.Call()
+	if hBar == 0 {
+		return
+	}
+	for _, top := range items {
+		label, _ := syscall.UTF16PtrFromString(top.Label)
+		if top.Type == "separator" {
+			continue
+		}
+		if len(top.Submenu) > 0 {
+			sub := buildMenu(ts, top.Submenu)
+			procAppendMenuW.Call(hBar, mfPopup|mfEnabled, sub, uintptr(unsafe.Pointer(label)))
+		} else {
+			// 顶层无子菜单：视为可点击菜单项。
+			var flags uintptr = mfString | mfEnabled
+			if top.Checked != nil && *top.Checked {
+				flags |= mfChecked
+			}
+			id := ts.nextID
+			ts.nextID++
+			ts.mu.Lock()
+			ts.items[id] = top.ID
+			ts.mu.Unlock()
+			procAppendMenuW.Call(hBar, flags, uintptr(id), uintptr(unsafe.Pointer(label)))
+		}
+	}
+	ts.mu.Lock()
+	ts.menuBar = hBar
+	ts.mu.Unlock()
+	procSetMenu.Call(hwnd, hBar)
+	procDrawMenuBar.Call(hwnd)
+}
+
+// trayDestroy 移除托盘图标并清理隐藏窗口。
+func trayDestroy(ts *trayState) {
+	if ts == nil {
+		return
+	}
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	if trayIconAdded {
+		nid := &notifyIconDataW{CbSize: uint32(unsafe.Sizeof(notifyIconDataW{})), HWnd: ts.hwnd, UID: 1}
+		procShellNotifyIconW.Call(nimDelete, uintptr(unsafe.Pointer(nid)))
+		trayIconAdded = false
+	}
+	if ts.menu != 0 {
+		procDestroyMenu.Call(ts.menu)
+		ts.menu = 0
+	}
+	if ts.menuBar != 0 {
+		procDestroyMenu.Call(ts.menuBar)
+		ts.menuBar = 0
+	}
+	if ts.icon != 0 {
+		procDestroyIcon.Call(ts.icon)
+		ts.icon = 0
+	}
+	if ts.hwnd != 0 {
+		procDestroyWindow.Call(ts.hwnd)
+		ts.hwnd = 0
+	}
+	trayStateInst = nil
+}
+
+var procDestroyWindow = user32win.NewProc("DestroyWindow")
+
+// trayCall 处理前端 __freedom_tray 请求。
+func (a *App) trayCall(method string, paramsJSON string) (result interface{}, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			result = nil
+			err = fmt.Errorf("freedom: tray method %q panicked: %v", method, r)
+		}
+	}()
+
+	var args map[string]json.RawMessage
+	if len(paramsJSON) > 0 && paramsJSON != "null" {
+		if err := json.Unmarshal([]byte(paramsJSON), &args); err != nil {
+			return nil, fmt.Errorf("freedom: tray method %q: invalid args: %w", method, err)
+		}
+	}
+	argStr := func(k string) string {
+		if v, ok := args[k]; ok {
+			var s string
+			if json.Unmarshal(v, &s) == nil {
+				return s
+			}
+		}
+		return ""
+	}
+
+	switch method {
+	case "tray.create":
+		ts, err := ensureTrayWindow(a)
+		if err != nil {
+			return nil, err
+		}
+		return nil, traySetIcon(ts, dataURLToBytes(argStr("icon")), argStr("tooltip"))
+	case "tray.destroy":
+		trayDestroy(trayStateInst)
+		return nil, nil
+	case "tray.tooltip":
+		ts := trayStateInst
+		if ts == nil {
+			return nil, fmt.Errorf("tray: 托盘未创建")
+		}
+		return nil, traySetIcon(ts, nil, argStr("tooltip"))
+	case "tray.menu":
+		ts := trayStateInst
+		if ts == nil {
+			return nil, fmt.Errorf("tray: 托盘未创建")
+		}
+		var items []menuItem
+		if v, ok := args["items"]; ok {
+			if err := json.Unmarshal(v, &items); err != nil {
+				return nil, fmt.Errorf("tray: 菜单格式错误: %w", err)
+			}
+		}
+		traySetMenu(ts, items)
+		return nil, nil
+	case "menu.set":
+		ts := trayStateInst
+		if ts == nil {
+			ts, err = ensureTrayWindow(a)
+			if err != nil {
+				return nil, err
+			}
+		}
+		var items []menuItem
+		if v, ok := args["items"]; ok {
+			if err := json.Unmarshal(v, &items); err != nil {
+				return nil, fmt.Errorf("menu: 菜单格式错误: %w", err)
+			}
+		}
+		hwnd := a.WindowHandle()
+		if hwnd == 0 {
+			return nil, fmt.Errorf("menu: 窗口未就绪")
+		}
+		menuBarSet(hwnd, ts, items)
+		return nil, nil
+	default:
+		return nil, fmt.Errorf("freedom: unknown tray method %q", method)
+	}
+}

package/templates/go/pkg/freedom/window_windows.go

@@ -183,16 +183,20 @@ func exeIconData() []byte {
 	if err := windows.GetModuleHandleEx(0, nil, &hInst); err != nil {
 		return nil
 	}
-	// FindResourceW(hModule, MAKEINTRESOURCE(1), MAKEINTRESOURCE(RT_ICON))
-	resInfo, err := windows.FindResource(hInst, windows.ResourceID(1), windows.ResourceID(rtIcon))
-	if err != nil {
-		return nil
-	}
-	data, err := windows.LoadResourceData(hInst, resInfo)
-	if err != nil {
-		return nil
+	// 先按 rcedit 注入约定 RT_ICON ID=1 读取；失败回退 ID=0（M3）。
+	// 不同注入工具写入的资源 ID 可能不同，硬编码单一 ID 会导致"标题栏图标正常
+	// 但 appIcon 空白"的中间态，此处与 loadExeIcon 的 ID 假设解耦。
+	for _, id := range []uintptr{1, 0} {
+		// FindResourceW(hModule, MAKEINTRESOURCE(id), MAKEINTRESOURCE(RT_ICON))
+		resInfo, err := windows.FindResource(hInst, windows.ResourceID(id), windows.ResourceID(rtIcon))
+		if err != nil {
+			continue
+		}
+		if data, err := windows.LoadResourceData(hInst, resInfo); err == nil {
+			return data
+		}
 	}
-	return data
+	return nil
 }
 
 // isPNG 判断字节流是否为 PNG 编码（rcedit 注入的 .ico 内嵌 PNG 时 RT_ICON 数据即 PNG）。
@@ -209,9 +213,15 @@ func loadExeIcon(cx, cy uintptr) uintptr {
 	if hInst == 0 {
 		return 0
 	}
-	// LoadImageW(hInst, MAKEINTRESOURCE(0), IMAGE_ICON, cx, cy, LR_DEFAULTCOLOR)
-	r, _, _ := procLoadImage.Call(hInst, 0, 1 /*IMAGE_ICON*/, cx, cy, 0 /*LR_DEFAULTCOLOR*/)
-	return r
+	// 先按 rcedit 注入约定 RT_GROUP_ICON ID=0 加载；失败回退 ID=1（M3：
+	// 与 appIcon 的 RT_ICON ID 假设解耦，兼容不同注入工具的资源 ID）。
+	for _, id := range []uintptr{0, 1} {
+		// LoadImageW(hInst, MAKEINTRESOURCE(id), IMAGE_ICON, cx, cy, LR_DEFAULTCOLOR)
+		if r, _, _ := procLoadImage.Call(hInst, id, 1 /*IMAGE_ICON*/, cx, cy, 0 /*LR_DEFAULTCOLOR*/); r != 0 {
+			return r
+		}
+	}
+	return 0
 }
 
 // exeAppIconDataURL 从当前 exe 的 PE 资源图标（rcedit 注入的 RT_ICON）提取为 PNG data URL。
@@ -353,10 +363,12 @@ func dibToPNG(data []byte) ([]byte, error) {
 	}
 	pxStart := int(biSize)
 	andStart := pxStart + pxLen
-	hasAndMask := heightRaw > 0 // 正高度表示 DIB 末尾带 AND mask
-	if !hasAndMask {
-		hasAndMask = andStart+andRowBytes*height <= len(data)
-	}
+	// AND mask 是否存在以实际数据长度为准（H1）：ICO 的 DIB 若数据不足
+	// （无 AND mask 段），andStart+andRowBytes*height 会超出 len(data)，
+	// 此时下方读取 data[andRow+x/8] 将越界 panic。
+	// 此前以 heightRaw>0 判定恒为真（上方已排除 heightRaw==0），
+	// 无 mask 的 ICO 会命中越界分支导致窗口控制崩壳。
+	hasAndMask := andStart+andRowBytes*height <= len(data)
 	img := image.NewRGBA(image.Rect(0, 0, width, height))
 	for y := 0; y < height; y++ {
 		srcY := height - 1 - y // DIB 自底向上：数据首行是图像末行

package/templates/go/temp_vet_test/main.go

@@ -0,0 +1,40 @@
+package main
+
+import "unsafe"
+
+// 写法B：widl 风格链式解引用
+func comVtableB(ppv uintptr, index uint32) uintptr {
+	vt := *(*uintptr)(*(*unsafe.Pointer)(unsafe.Pointer(ppv)))
+	return *(*uintptr)(unsafe.Pointer(vt + uintptr(index)*8))
+}
+
+// 写法D：先转 unsafe.Pointer 立即传给子函数
+func comVtableD(ppv uintptr, index uint32) uintptr {
+	return comVtableDPtr(unsafe.Pointer(ppv), index)
+}
+
+func comVtableDPtr(pp unsafe.Pointer, index uint32) uintptr {
+	vt := *(*uintptr)(pp)
+	return *(*uintptr)(unsafe.Add(unsafe.Pointer(vt), uintptr(index)*8))
+}
+
+// 写法E：uintptr 参数直接转结构体指针再读字段
+type unkBox struct{ v unsafe.Pointer }
+
+func comVtableE(ppv uintptr, index uint32) uintptr {
+	b := (*unkBox)(unsafe.Pointer(ppv))
+	slots := unsafe.Slice((*uintptr)(b.v), int(index)+1)
+	return slots[index]
+}
+
+// 写法F：类型化数组头 + Slice
+func comVtableF(ppv uintptr, index uint32) uintptr {
+	obj := (*[1]unsafe.Pointer)(unsafe.Pointer(ppv))
+	vt := *obj
+	slots := unsafe.Slice((*uintptr)(vt[0]), int(index)+1)
+	return slots[index]
+}
+
+func main() {
+	_, _, _, _ = comVtableB(0, 0), comVtableD(0, 0), comVtableE(0, 0), comVtableF(0, 0)
+}

package/templates/go/vet_err.txt

@@ -0,0 +1 @@
+pkg\freedom\syscap_windows.go:56:30: possible misuse of unsafe.Pointer

package/templates/go/vet_err2.txt

@@ -0,0 +1,2 @@
+pkg\freedom\syscap_windows.go:56:22: possible misuse of unsafe.Pointer
+pkg\freedom\syscap_windows.go:61:32: possible misuse of unsafe.Pointer

package/templates/project/freedom.config.js

@@ -18,6 +18,14 @@ export default {
   // 是否开启 WebView 开发者工具。
   debug: false,
 
+  // 安全模式，在终端随时可改，三选一：
+  //   'none'  - 明文资源（默认，兼容历史产物）
+  //   'basic' - 明文资源 + 构建期加固提示
+  //   'high'  - resources 整体加密为 app.bin（磁盘无明文 HTML/配置），
+  //             壳内存解密 + 完整性校验，另含 anti-debug / 进程隐藏
+  // 终端命令：freedom security <none|basic|high>，或在 freedom build 时传 --security <mode>
+  security: 'none',
+
   // 标题栏策略，在终端随时可改，二选一：
   //   'native'    - 保留系统原生标题栏，标题栏图标与 exe 图标一致
   //   'frameless' - 完全无边框，标题栏与 Windows 原生最小化 / 最大化 / 关闭按钮均不存在，

package/templates/project-minimal/freedom.config.js

@@ -0,0 +1,58 @@
+// Freedom 应用配置（极简模板）。
+// 构建时由 freedom CLI 读取，生成对应的壳层配置。
+export default {
+  // 应用名（窗口标题 / 可执行文件名）。
+  name: 'freedom-app',
+
+  // 窗口初始尺寸（像素）。
+  width: 1024,
+  height: 720,
+
+  // 窗口最小尺寸（设为 0 表示不限制）。
+  minWidth: 400,
+  minHeight: 300,
+
+  // 启动时是否在屏幕居中。
+  center: true,
+
+  // 是否开启 WebView 开发者工具。
+  debug: false,
+
+  // 安全模式，在终端随时可改，三选一：
+  //   'none'  - 明文资源（默认，兼容历史产物）
+  //   'basic' - 明文资源 + 构建期加固提示
+  //   'high'  - resources 整体加密为 app.bin（磁盘无明文 HTML/配置），
+  //             壳内存解密 + 完整性校验，另含 anti-debug / 进程隐藏
+  // 终端命令：freedom security <none|basic|high>，或在 freedom build 时传 --security <mode>
+  security: 'none',
+
+  // 标题栏策略，在终端随时可改，二选一：
+  //   'native'    - 保留系统原生标题栏（极简模板默认：不引入自绘标题栏，开箱即用）
+  //   'frameless' - 完全无边框，关闭 / 最大化 / 最小化按钮由前端自绘。
+  //                 切换 frameless 后需在前端自行实现窗口控制按钮（完整示例见完整模板 full：
+  //                 freedom init --template full 生成的 index.html / src/main.js）。
+  // 终端命令：freedom titlebar <native|frameless>
+  titlebar: 'native',
+
+  // 应用图标（可执行文件 / .app 的图标）：
+  //   Windows 需 .ico（推荐含 16/32/48/256 多尺寸），构建时注入 exe 资源；
+  //   macOS 需 .icns，构建时放入 .app/Contents/Resources 并写入 Info.plist。
+  //   值为相对项目根目录的路径或绝对路径，未配置则使用壳默认图标。
+  // 终端命令：freedom icon <path>（Windows 主用）
+  icon: undefined,
+
+  // 产物输出目录（相对项目根目录或绝对路径）：
+  //   'dist' - 输出到 dist/ 子目录（默认）
+  //   '.'    - 直接输出到项目根目录（dist 的上级），exe 与单文件 index.html 就地生成
+  //   'build/app' 等任意路径亦可
+  // 注意：输出到项目根目录时不会覆盖项目源文件（index.html 仅保留 src 源文件）。
+  outDir: 'dist',
+
+  // 后端策略：
+  //   undefined            - 仅使用框架内置能力（ping / 窗口控制），不启动独立后端进程
+  //   { command, args }    - 启动任意语言后端进程（Go/Node/Python/Rust 均可），
+  //                          经 stdin/stdout NDJSON 与壳通信，方法直接暴露给前端
+  // 示例（Node 后端）：
+  //   backend: { command: 'node', args: ['backend/main.mjs'] }
+  // backend: undefined,
+};