feat(sdk): 反代声明（ProxyDef / RegisterProxy）—— 插件声明服务，HomeAgent 反代出去

配套核心仓「webui 通用反向代理」。SDK 1.4.0 尚未发布，接口未冻结，
本次按开发期自由变更处理（正式发版时并入版本号推进）。

## 声明契约

plugin.json 的 proxies 字段（声明式，静态可发现）或 RegisterProxy
（运行期，供没有 plugin.json 的内置插件用）：

    {"name":"ui","host":"myapp","path":"/p/myapp","strip_path":true,
     "target":"127.0.0.1:12100","auth":"homeagent"}

命名与既有能力对齐（ToolDef / ChannelDef / ConfigDef / RegisterTool /
ToolRegistrar）——第一版写成 ProxyDecl / DeclareProxy / ProxyDeclarer
被评审指出「跟 SDK 其他接口不是一个风格」，已全面改名。

## strip_path：Path 的两种语义

Path 不能一刀切成「原样保留」，真实需求有两种且**不能自动判定**
（同一个 path 在两种语义下都说得通，猜错即全部 404 且像上游故障）：

  strip_path 缺省/false（别名模式）—— path 是上游真实路径的一部分
    /api/v1/device/ws + path=/api/v1/device → 上游收到原样
    适用：客户端**已硬编码**路径的机器接口（设备网关即如此）

  strip_path=true（前缀模式）—— path 只是门户上的挂载点
    /p/myapp/api/status + path=/p/myapp → 上游收到 /api/status
    适用：自带 UI 的服务（前端用相对路径）

非法组合（strip_path 而无 path）被 ValidateProxyDef 挡住。

## 单一入口原则（契约级要求）

一个声明 = 一个入口。两种挂载形态对「根路径」处理截然不同：
Host 形态下根路径是插件的根（fetch('/api/x') 天然正确）；
Path 形态下根路径**属于门户**，同样代码会打到门户自己身上
（静默错路由：页面能开、功能全坏）。

故被反代的插件必须**一律使用相对路径**，绝不硬编码以 / 开头的绝对路径。
这样同一份前端在两种形态下都正确，插件不必知道自己被挂在哪，
反代层也能按外部条件（子域是否有证书/放行）自由选择形态。

## 判据

sdk/proxy_test.go：两种语义的映射、非法组合、单一入口原则的契约存在性。
hmapdev proxy_config_test.go：schema 漂移保护（新增字段忘了同步就判红）、
非法声明在**打包时**就被拒（不必装到 HomeAgent 才看到）。

两模块 go test 全绿；文档站已重新生成（ProxyDef 与单一入口原则进入
docs/api/misc.md 与 llms-full.txt）。

## 顺带修回的一处（此前随工作树丢失）

writePluginJSON 漏写 proxies 键 —— 漏写的话插件装得上、启动正常、
就是不出现，没有任何报错。该 bug 曾在核心仓侧出现过（判据抓到过），
这次移植时由 TestWritePluginJSONPreservesProxies 再次判红并修复。

sdk/proxy_test.go

@@ -0,0 +1,163 @@
+package sdk
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestProxyAuthDefaultsToHomeAgent(t *testing.T) {
+	// 空串必须归一化为「HomeAgent 统一保护」——这是安全默认。
+	// 若哪天有人把默认改成 none，这条会立刻红。
+	if got := EffectiveProxyAuth(""); got != ProxyAuthHomeAgent {
+		t.Fatalf("空 auth 应归一化为 %q，实际 %q", ProxyAuthHomeAgent, got)
+	}
+	if got := EffectiveProxyAuth(ProxyAuthNone); got != ProxyAuthNone {
+		t.Fatalf("显式 none 应保持 none，实际 %q", got)
+	}
+	for _, ok := range []string{"", ProxyAuthHomeAgent, ProxyAuthNone} {
+		if !ValidProxyAuth(ok) {
+			t.Errorf("%q 应合法", ok)
+		}
+	}
+	for _, bad := range []string{"nope", "HOMEAGENT", "None", "true"} {
+		if ValidProxyAuth(bad) {
+			t.Errorf("%q 应非法", bad)
+		}
+	}
+}
+
+func TestValidProxyHostLabel(t *testing.T) {
+	legit := []string{"huawei", "a", "a-b", "abc123", "0", "x" + string(make([]byte, 0)) + "yz"}
+	for _, s := range legit {
+		if !ValidProxyHostLabel(s) {
+			t.Errorf("%q 应为合法 label", s)
+		}
+	}
+	bad := []string{
+		"", "-a", "a-", "-", "a_b", "a.b", "A", "aB", "a b",
+		"a/b", "a:b", string(make([]byte, 64)), // 超长 63
+	}
+	for _, s := range bad {
+		if ValidProxyHostLabel(s) {
+			t.Errorf("%q 应为非法 label", s)
+		}
+	}
+	// 边界：恰好 63 合法，64 非法
+	l63 := ""
+	for i := 0; i < 63; i++ {
+		l63 += "a"
+	}
+	if !ValidProxyHostLabel(l63) {
+		t.Error("63 字符应为合法 label")
+	}
+	if ValidProxyHostLabel(l63 + "a") {
+		t.Error("64 字符应为非法 label")
+	}
+}
+
+func TestNormalizeProxyHost(t *testing.T) {
+	cases := map[string]string{
+		"huawei_smarthome": "huawei-smarthome", // 下划线不是合法 DNS label
+		"webui":            "webui",
+		"UPPER_Case":       "upper-case",
+		"a__b":             "a--b",
+		"__x__":            "x",
+		"---":              "plugin", // 全非法 → 保守回退
+		"":                 "plugin",
+		"a.b.c":            "abc",
+	}
+	for in, want := range cases {
+		if got := NormalizeProxyHost(in); got != want {
+			t.Errorf("NormalizeProxyHost(%q) = %q，期望 %q", in, got, want)
+		}
+	}
+	// 归一化结果必须自身合法（产物自洽）
+	for _, in := range []string{"huawei_smarthome", "UPPER_Case", "__x__", "a.b.c", "非常长的名字非常长的名字非常长的名字非常长的名字非常长的名字非常长的名字非常长的名字"} {
+		if got := NormalizeProxyHost(in); !ValidProxyHostLabel(got) {
+			t.Errorf("NormalizeProxyHost(%q) = %q 不合法", in, got)
+		}
+	}
+}
+
+func TestValidateProxyDef(t *testing.T) {
+	valid := []ProxyDef{
+		{Target: "127.0.0.1:12100"},
+		{Target: "http://127.0.0.1:12100"},
+		{Target: "127.0.0.1:12100", Host: "huawei"},
+		{Target: "127.0.0.1:12100", Auth: ProxyAuthNone},
+		{Target: "127.0.0.1:12100", Auth: ProxyAuthHomeAgent, WebSocket: true},
+		{Target: "127.0.0.1:3000/base", Host: "x"},
+		{Target: "https://example.com", Host: "ext"}, // 远程上游也允许（由 auth 决定安全性）
+	}
+	for _, d := range valid {
+		if msg := ValidateProxyDef(d); msg != "" {
+			t.Errorf("%+v 应合法，却报: %s", d, msg)
+		}
+	}
+
+	bad := []ProxyDef{
+		{},                                       // 无 target
+		{Target: "   "},                          // 空白 target
+		{Target: "127.0.0.1:12100", Auth: "yes"}, // auth 非法
+		{Target: "127.0.0.1:12100", Host: "a_b"}, // host 非法
+		{Target: "127.0.0.1:12100", Host: "-x"},
+		{Target: "127.0.0.1:12100", Host: "X"},
+		{Target: "://12100"},           // 无主机
+		{Target: "http:///path"},       // 无主机
+		{Target: "127.0.0.1:notaport"}, // 端口非数字
+	}
+	for _, d := range bad {
+		if msg := ValidateProxyDef(d); msg == "" {
+			t.Errorf("%+v 应被拒绝，却通过了", d)
+		}
+	}
+}
+
+// ---- 单一入口原则 ----
+
+// 被反代的插件必须能同时适配 Host 形态与 Path 形态。这两条判据把
+// 「插件内部不得用根绝对路径」这条契约钉在**可执行**的层面：
+// 声明合法不代表它的资源能被两种形态访问到 —— 后者取决于插件前端的写法，
+// 而 SDK 只能把要求写清楚并给出校验工具。
+func TestSingleEntryPrincipleDocumented(t *testing.T) {
+	// Path 形态下插件前端必须用相对路径，否则请求会打到门户自己。
+	// 这是**文档级约定**，只能靠 review 与这份判据共同保证：
+	// 判据确保 SDK 里确实写明了这条要求（防止后来者删掉注释）。
+	src, err := os.ReadFile("proxy.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"单一入口原则",
+		"相对路径",
+		"根绝对路径",
+	} {
+		if !strings.Contains(string(src), want) {
+			t.Errorf("SDK 文档缺少「%s」—— 单一入口原则是反代的硬要求，不能只存在于口头约定里", want)
+		}
+	}
+}
+
+// strip_path 的两种语义必须由声明者显式选，且非法组合要被挡住。
+func TestStripPathValidation(t *testing.T) {
+	// 合法：两种模式
+	for _, d := range []ProxyDef{
+		{Target: "127.0.0.1:1", Path: "/p/app", StripPath: true},
+		{Target: "127.0.0.1:1", Path: "/api/v1/device", StripPath: false},
+	} {
+		if msg := ValidateProxyDef(d); msg != "" {
+			t.Errorf("应合法却被拒: %+v → %s", d, msg)
+		}
+	}
+	// 非法：strip_path 但没有 path（没有可剥的前缀）
+	if msg := ValidateProxyDef(ProxyDef{Target: "127.0.0.1:1", StripPath: true}); msg == "" {
+		t.Error("strip_path=true 而无 path 应被拒（没有可剥的前缀）")
+	}
+	// 非法：前缀模式挂到根会吞掉整个门户。
+	// 实际由「不应以 / 结尾」规则挡下（"/" 同时是前缀又以 / 结尾），
+	// 这里断言的是**行为**：这种声明无论如何都不能通过。
+	if msg := ValidateProxyDef(ProxyDef{Target: "127.0.0.1:1", Path: "/", StripPath: true}); msg == "" {
+		t.Error("path=\"/\" + strip_path 应被拒（会覆盖整个门户）")
+	}
+}