jianf/HomeAgent
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/HomeAgent.git synced 2026-11-01 06:47:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: 模块化内核（编译期依赖图定序）+ 密钥防火墙 + 插件三态生命周期 (#10)

Browse Source 
* feat(kernel): 模块化内核 + 编译期依赖图定序

把单体 init 序列拆成「模块自声明依赖 + 编译期生成依赖图 + 运行期只读图」。

## 为什么

原 cmd/homed/main.go 里 17 步 init 是**手写顺序**，依赖关系只存在于
注释和人脑里。实测踩到的坑（见 docs/zh/kernel-modularization-design.md）：
 · nlp.defaultParser 被 initONNXParser 写、被 distiller 读，两者相距 60 行，
   只靠 ticker 10min 才没炸（隐式依赖，无声明）
 · 加一个模块要人肉找"该插在哪"，插错的表现是运行期 nil 解引用
 · 关停是 defer ks.CloseAll()，而热更新路径 os.Exit(42) **跳过 defer**
   ⇒ docStore/distiller/textMem 的 flush 全部丢失（每次热更新都发生）

## 怎么改

- internal/kernelboot/：KernelState（一个结构体收全部包级共享变量，字段
  nil 安全）、Module 接口、graphfile（依赖图编解码 + 与二进制 hash 对账）、
  scheduler（按 BFS 层并行 Init）、syncbus（层边界写通知）、
  lifecycle（Quiesce/Resume 可逆伪关机，区别于一次性 CloseAll）
- internal/kernelmod/<name>/：每个模块一个文件夹，Requires/Provides 自声明；
  all/all.go 是唯一的 import 清单（Go 循环导入约束）
- cmd/homed-depgraph：编译期生成依赖图，Makefile 注入 digest
- 运行期只**读**图，不计算顺序（顺序是编译期决定的，源码里没有中央清单）

## 判据

kernelboot 8 条 + 图失败模式 7 条（全部拒绝并给准确错误）+ 模块目录数
与注册表一致性。变异测试 15/15 咬住，含：
 · 删掉 AddCloser 的锁 → -race 报数据竞争
 · Scheduler 同批跑去重 → 203 vs 200
 · 图 hash 不匹配 → 拒绝启动

## 顺带修的缺陷

热更新路径漏调模块关闭 ⇒ 显式 stopKernelModules()，并用 AST 判据钉住
"必须在 os.Exit 之前"（字符串检查在本仓已骗过我三次）。

实测：冷启动 1630ms（5 层/17 模块，原 17 步串行）；生产 22 插件全部建链。

* feat(security): 密钥防火墙 + 配置加密 + close 纪律

## 密钥防火墙

模型只见别名、不见明文；插件工具调用入口（StageHost.ExecuteTool）做入向
回填。三维能力：
 · 出向：工具输出里的密钥被替换成 [[secret:name]] 别名后才进上下文
 · 入向：模型传别名，入口处填回真值（插件完全无感知）
 · 存储：config.db 里不存明文（0644 的库可读），敏感值独立 0600 文件

模式库「宁漏勿误伤」：宁可漏掉一次替换，也不把正常文本误当密钥。

## 配置加密

- internal/security/{codec,key,keyring,store,global}.go：AES-256-GCM，
  enc:v1: 前缀，密钥轮换（OldKeys 解码 + 新钥加密）
- harden.go：数据目录权限收紧
- embedded.go：支持内嵌主密钥（可选，仍保留外部 key 文件路径）
- EncryptExistingSecrets / AuditSecrets：启动时幂等迁移 + 审计

## close 纪律（用户明确要求：只要调 close 就要有前置检查）

internal/safeclose：Safe / SafeFunc。全仓 37 处裸 close(chan) → 0。
关键教训（都写进注释和判据）：
 · `select { case <-ch: default: close(ch) }` **不是**并发安全的
   （两个 goroutine 可同时命中 default）—— healthcheck 原先是这种写法
 · `sync.Once` **不可重入**：X.Do(func(){ Safe(&X, ...) }) 会自锁，
   症状是 go test 直接挂住（3 个包 600s 超时），栈里只有嵌套的 Once.Do
 · map 里按请求持有的 channel（mcp/stdio.go、clawhubadapter/sidecar.go）
   改成 *pendingRPC 包装，每通道一个 once

## 判据

security 全量 + TestNoBareCloseOutsideSafeclose（AST 级扫描，含注释剥离）
+ TestNoNestedSelfOnceDeadlock（正则修正：\w+ 不匹配点号，捕获组要含 '.'）。
变异 2/2 咬住。全量 52 包 ok。

* feat(plugin+deploy): 插件三态生命周期、数据目录迁移、发行包修复

## 插件三态生命周期（用户要求：自动启动 / 启用但不自动启动 / 禁用）

- Manifest 新增 requires_facilities / auto_start（*bool，用于区分
  "未声明"与"显式 false"）
- plugin-host 模块（internal/kernelmod/pluginhost）：用 kernelboot.Scheduler
  按依赖时机拉起，**不再手写两阶段**
- 运行态停启 StopPlugin/StartPlugin **可逆**：不写 disabled_plugins
  （不改用户决定）、不置 shuttingDown（之后还能加载）、会摘掉注册面
- 与 StopAll 的区别写进注释 —— StopAll 置 shuttingDown 后**永久无法加载**，
  那是进程退出用的，误用于"暂停"就是关了就死

## 数据目录迁移（伪关机 → 迁移 → 唤醒）

- kernelboot/lifecycle.go：Quiesce/Resume（可逆，区别于一次性 CloseAll），
  逆序暂停、逆序恢复、Pause 失败回滚
- kernelboot/migrate.go：BeginMigration/End 编排（先停插件 → 再停内核写者
  → 等在途归零）
- distiller/textmem 增 Pause/Resume 门（不是 cancel —— cancel 不可逆，
  恢复要重建整个对象）
- 模块 migration：体检 + 生成可执行迁移脚本

★ 迁移脚本的三个实测教训（都写成了判据）：
 1. 无条件改 /etc/systemd/system ⇒ 演练把**生产** -data 改成了演练目录。
    加 --dry-run（零改动）+ 强制校验 systemd 当前 -data == OLD
 2. 本机没装 rsync，脚本在"服务已停、数据未搬"处硬失败 ⇒ cp -a 回退，
    并明确警告不保硬链接/ACL（生产 plugindev 有大量 git 硬链接）

## 发行包修复（全部经实测确认）

 1. package-linux.sh **完全漏打 depgraph.bin** ⇒ 内核 exit 1
    （"生产构建（内嵌 hash 非空）但读不到依赖图"）
 2. build_homed 不走 Makefile ⇒ 单独修 Makefile 无效，必须同时生成图+注入
 3. build.sh 的 LDFLAGS 用**历史模块路径 gitcode.com** ⇒ -X 静默 no-op
    ⇒ --version 显示 unknown
 4. Makefile -ldflags 用**单引号** ⇒ 注入了字面 $GRAPH_HASH

## ★ build.sh 的版本号必须校验（真实事故）

原 `VERSION="$(git describe --tags --dirty)"`。无 tag 分支上它返回**分支名**
`backup/pre-identity-rewrite-20261005-51-g03d87a4e-dirty`，被注入 meta.Version
⇒ 插件握手判据 MajorVersion() 把整串当主版本 ⇒ **22 个子进程插件全部
握手失败**（"主版本不匹配"）。内核活着、systemd active、日志每条都像
插件的问题 —— 实际是发行包带着非法版本号。

修法：git describe 只在形如 vX.Y.Z 时采用，否则回退 meta.Version（权威源），
并对最终值做形态守卫。deploy/packaging/version_guard_test.go 3 条判据，
变异 2/2 咬住。

## deb 的 systemd unit 改为 guard 模式

ExecStart=/usr/bin/homed --role=guard --data /var/lib/homeagent
（worker exit 42 → guard 重拉，不经过 systemd、不计失败）
含 RestartSteps/RestartMaxDelaySec/TimeoutStopSec + 硬化
（NoNewPrivileges/ProtectSystem/ProtectHome/DevicePolicy/ReadWritePaths）。

## 其他

- internal/plugin/proc：非法 JSON 帧的报错**可定位**（内容摘要 + 可能原因 +
  修法）。生产实测 1038 条非法帧（插件往 stdout 打日志 = 污染协议通道）
- 示例插件 4 个 14 处 fmt.Printf → log.Printf
- hmapdev 模板同步修复；scaffold 判据剥离注释（模板注释里就含 fmt.Printf）

* chore: 收尾（主密钥轮换命令、IPC/知识库加固、SDK 对齐）

- cmd/homed-key-rotate：把 security 里的 RotateKey/RotateKeyFile/RekeySecrets
  串成一条**可执行**的运维路径。没有它，E-1 就只是库里的能力而不是
  "出事时能做的事"，而轮换的价值恰恰在于能执行。
- cmd/homed：kmod_runtime（模块装配入口）、plugins_scheduled（failback
  白名单）、memcandidate、bootstrap_order_test / shutdown_flush_test
- internal/ipc、internal/devicebridge、internal/knowledge：配套加固
- third_party/homeagent-sdk/sdk：PluginMgrAPI 增三态能力（mgrStop/mgrStart/
  mgrIsRuntimeStopped）+ settings 对齐

判据：bootstrap_order_test（启动顺序不依赖手写序列）、
shutdown_flush_test（停机的两条路径必须对称 —— exit 42 会跳过 defer，
热更新路径下模块关闭/flush 曾全部丢失）。

* test(security): 测试夹具改用不可误认的占位值（修 push protection 拦截）

GitHub secret scanning 拦住了推送：三处测试夹具用了"看起来像真密钥"的
字面量：

  internal/security/prefilter_test.go:39
  internal/security/store_test.go:177
  internal/security/survey_test.go:20

它们全是**假密钥**（`AKIAIOSFODNN7EXAMPLE` 是 AWS 官方文档的标准示例，
其余是 `abcdefghij...` 这类可读占位符），但扫描器无法区分 —— 它只看形态。

★ 不绕过（不用 unblock URL、不加 allowlist）：直接改夹具。
原因：一旦允许"假密钥可以通过"，真密钥混进来时就没有最后一道门了。

改法：保留**模式库匹配所需的结构**，把可识别内容换成 FAKE：
  glpat-abcdefghijklmnopqrst       → glpat-FAKE-TEST-TOKEN-NOT-REAL
  sk-abcdefghij...012345           → sk-FAKE-TEST-KEY-NOT-REAL-0000000
  AKIAIOSFODNN7EXAMPLE             → AKIA0000FAKE0000TEST   (保持 20 字符)
  ASIAIOSFODNN7EXAMPLE             → ASIA0000FAKE0000TEST
  xoxb-123456789012-abcdefghijklmnop → xoxb-FAKE-TEST-TOKEN-NOT-REAL

★ 中途踩到一次：AWS 键的模式是 `\b(AKIA|ASIA)[0-9A-Z]{16}\b`（共 20 字符），
我第一次替换成 19 字符的 `AKIAFAKETESTKEY0000` ⇒ 模式匹配不上 ⇒
TestSurvey_WhatIsCaught / TestRecognizesCommonShapes /
TestPrefilterNeverBlocksRealMatches 三条当场变红。
判据正确地拒绝了"为了过扫描器而削弱覆盖"。

顺带核实：全仓 grep 无任何真实密钥泄漏。

* fix(packaging): package-linux.sh 的版本解析与 build.sh 统一

上一版只修了 build.sh，漏了 package-linux.sh —— 它仍只看 git describe：

  VERSION="${VERSION:-$(git describe --tags --dirty)}"

无 tag 分支上 git describe 返回**分支名**
（backup/pre-identity-rewrite-20261005-56-g98850e1），守卫会正确拒绝，
但要求人**手动传 VERSION** 才能打包。而 build.sh 早已能自动回退 meta.Version
⇒ 同一个版本，走 build.sh 打得出来、走 package-linux.sh 打不出来。

危害不只是"要手动传参"：运维为了跑通会去掉守卫，而分支名一旦进
meta.Version 就是**插件协议主版本**的来源 ⇒ 22 个子进程插件全部握手失败
（这是真实发生过的事故，见 3efa4e5）。

修法：两个脚本用同一套规则（git describe 仅在 vX.Y.Z 形态时采用，
否则回退 meta.Version），并对最终值做形态守卫。

判据：TestBothPackagingScriptsShareVersionRules —— 逐个读两个脚本，
要求都能从 meta/meta.go 取权威版本、都校验 git describe 形态。
变异（把 package-linux.sh 改回旧规则）咬住并准确指出是哪个脚本。

实测：不传 VERSION 跑 package-linux.sh，输出
  [PKG] warn: git describe 给出非版本串（...），改用 meta.Version=1.4.0
  Version: 1.4.0

* fix(test): 跨仓判据在 CI 上应 skip 而非 fail（修 PR 双红）

CI 上 "Go build / vet / test" 与 "Build linux/amd64" 双红：

  --- FAIL: TestHmapdevTemplateImplementsAllPluginMgrMethods
      bridge_sync_test.go:170: 读模板: open
      ../../../third_party/homeagent-sdk/tools/hmapdev/templates/proc_main.go.tmpl:
      no such file or directory

## 根因：判据依赖了一个**被 gitignore 的路径**

`.gitignore:33` 有 `third_party/homeagent-sdk/tools/`（SDK 仓自治，本仓不跟踪）。
于是：
  · 本机（完整 SDK 检出）有该文件 ⇒ 判据通过
  · CI（只 checkout 本仓）没有该文件 ⇒ Fatalf ⇒ **必红**

我提交时只在本机跑测试、没看 CI，所以这个问题拖到 PR 才暴露。

## 修法

文件缺失时 `t.Skipf` 而不是 `t.Fatalf`。

★ 这不是"放弃检查"：
  · 跨仓一致性由 **SDK 仓自己的判据**守着
    （tools/hmapdev/scaffold_stdout_test.go 等），那里才是模板的真实归属地
  · 本判据在本机开发时**仍然生效**（已验证：有文件时 PASS，缺文件时 SKIP）

## 验证

 · 本机（有文件）  → PASS（判据真跑）
 · 模拟 CI（移走 tools/）→ SKIP（不再 fail）
 · 全量 53 包 ok / 0 fail

## 顺带

同目录还有 e2e_template_test.go 也读 tools/，但它是 `//go:build` 门控的
e2e 判据，CI 默认不跑，无需处理。

---------

Co-authored-by: JianFeeeee <JianFeeeee@users.noreply.gitcode.com>
This commit is contained in:
JianFeeeee
2026-10-17 19:18:24 +08:00
committed by GitHub
parent 03d87a4e21
commit a68d6a428c
266 changed files with 30185 additions and 1424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
cmd/homed-centroid/main.go
View File

@ -11,8 +11,9 @@
// - 库增长后中心过期（中心是块集的均值，块集变了它就偏）
//
// 用法：
// homed-centroid -db <graph.db> # 自动取库内指纹
// homed-centroid -db <graph.db> -fingerprint <hex> # 显式指定
//
// homed-centroid -db <graph.db> # 自动取库内指纹
// homed-centroid -db <graph.db> -fingerprint <hex> # 显式指定
package main
import (
@ -66,4 +67,4 @@ func main() {
if !anomalous {
fmt.Println(" （各向异性不显著，召回不会做中心化；中心已存备用）")
}
}
}

142
cmd/homed-depgraph/main.go Normal file
View File

@ -0,0 +1,142 @@
// homed-depgraph 产出内核模块的**启动依赖图制品**（设计 §2.5）。
//
// ## 用户的设计（原话）
//
// > 启动顺序是编译期间按照声明的依赖顺序生成的启动依赖图排列的
//
// 本工具就是那个"编译期生成器"：
//
// ① import 模块登记表（internal/kernelmod/all ⇒ 各模块 init 自注册）
// ② 用各模块**自己的** Requires()/Provides() 算分层（BFS）
// ③ 把【模块 + 边 + 层号】编成 depsgraph.bin，并输出 digest
//
// 运行期内核**读**这份图即可（不再自己算顺序）。
//
// ## 用法
//
// homed-depgraph -out <homed 目录>/depgraph.bin # 产出制品
// homed-depgraph -print # 只打印计划（评审用）
// homed-depgraph -digest # 只输出 digest（供 -ldflags 注入）
//
// ## ★ 拒绝产出空图 / 无解图
//
// 空图会让内核认为"没有依赖" ⇒ 按一个**错误的计划**启动 —— 比报错危险得多。
// 依赖图无解（缺依赖/环/重名）时也拒绝产出：那是结构性错误，
// 应在编译期就报出来，而不是留给运行期。
package main
import (
"flag"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"github.com/JianFeeeee/HomeAgent/internal/kernelboot"
"github.com/JianFeeeee/HomeAgent/internal/kernelmod"
// ★ 把全部内核模块**引入编译** —— 这就是"编译期收集各模块声明"的落点。
// 各模块在自己的 init() 里 kernelmod.Register(...)。
_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/all"
)
func main() {
out := flag.String("out", "", "输出路径（默认 <二进制目录>/depgraph.bin）")
printPlan := flag.Bool("print", false, "打印启动计划（不落盘）")
digestOnly := flag.Bool("digest", false, "只输出 digest（供 -ldflags 注入）")
flag.Parse()
if d := kernelmod.Duplicates(); len(d) > 0 {
fmt.Fprintf(os.Stderr, "homed-depgraph: 模块名重复注册: %v\n", d)
os.Exit(1)
}
mods := kernelmod.Registered()
if len(mods) == 0 {
fmt.Fprintln(os.Stderr,
"homed-depgraph: 没有任何模块被登记 —— 拒绝产出空图。\n"+
"空图会让内核认为'没有依赖'，从而按一个**错误的计划**启动。\n"+
"检查 internal/kernelmod/all 是否 import 了各模块包。")
os.Exit(2)
}
// ★ 编译期就算出分层 —— 这是"顺序由编译期决定"的落点。
plan, err := kernelboot.Build(mods)
if err != nil {
fmt.Fprintf(os.Stderr, "homed-depgraph: ★ 依赖图无解，拒绝产出制品:\n%v\n", err)
os.Exit(1)
}
edges := planToEdges(plan)
if *printPlan {
fmt.Print(renderPlan(plan))
}
if *digestOnly {
fmt.Println(kernelboot.GraphDigest(edges))
return
}
data := kernelboot.EncodeGraph(edges)
path := *out
if path == "" {
exe, err := os.Executable()
if err != nil {
fmt.Fprintf(os.Stderr, "homed-depgraph: 无法确定输出目录: %v\n", err)
os.Exit(1)
}
path = filepath.Join(filepath.Dir(exe), kernelboot.GraphFileName)
}
// 写临时文件再 rename：避免半截文件被读到
//（自校验也能拦住截断，但原子替换能避免"那一刻读到坏图"的噪音）。
tmp := path + ".tmp"
if err := os.WriteFile(tmp, data, 0o644); err != nil {
fmt.Fprintf(os.Stderr, "homed-depgraph: 写 %s: %v\n", tmp, err)
os.Exit(1)
}
if err := os.Rename(tmp, path); err != nil {
fmt.Fprintf(os.Stderr, "homed-depgraph: 替换 %s: %v\n", path, err)
os.Exit(1)
}
fmt.Printf("已产出启动依赖图: %s（%d 个模块，%d 层）\n", path, len(edges), len(plan.Layers))
fmt.Printf("digest（注入 -ldflags -X ...EmbeddedGraphHash=%s）\n",
kernelboot.GraphDigest(edges))
}
// planToEdges 把分层计划转成图记录（含**编译期算好的层号**）。
func planToEdges(plan *kernelboot.Plan) []kernelboot.GraphEdge {
var out []kernelboot.GraphEdge
for layer, mods := range plan.Layers {
for _, m := range mods {
out = append(out, kernelboot.GraphEdge{
Name: m.Name(),
Provides: m.Provides(),
Requires: m.Requires(),
Layer: layer, // ★ 编译期定序
})
}
}
sort.Slice(out, func(i, j int) bool {
if out[i].Layer != out[j].Layer {
return out[i].Layer < out[j].Layer
}
return out[i].Name < out[j].Name
})
return out
}
// renderPlan 把分层计划渲染成**给人看**的文本（供 -print）。
//
// 格式刻意稳定：它会进 PR / 运维记录，因此同一份声明必须渲染出逐字相同的结果。
func renderPlan(plan *kernelboot.Plan) string {
var b strings.Builder
b.WriteString("内核模块启动计划（编译期由依赖声明算出，BFS 分层，同层并行）:\n")
for i, layer := range plan.Layers {
names := make([]string, 0, len(layer))
for _, m := range layer {
names = append(names, m.Name())
}
sort.Strings(names)
fmt.Fprintf(&b, " 第 %d 层（%d 个，可并行）: %s\n", i, len(names), strings.Join(names, ", "))
}
return b.String()
}

135
cmd/homed-key-rotate/main.go Normal file
View File

@ -0,0 +1,135 @@
// homed-key-rotate：主密钥轮换（E-1）。
//
// ## 为何必须有这个命令
//
// `security` 包里的 `RotateKey` / `RotateKeyFile` / `RekeySecrets` 只是**零件**。
// 没有一条可执行的路径把它们串起来，E-1 就只是库里的能力，而不是
// 运维真能做的事 —— 而轮换的价值恰恰在于「出事时能执行」。
//
// ## 做三件事，顺序不可换
//
// ① 重加密变量库（security/variables.json）→ 新钥
// ② 写 security.keyring（旧钥降为只读历史）
// ③ 重加密 config.db 里的密文
//
// ★ 为什么必须「先重加密、后写 keyring」：
// 反过来的话，进程在中间崩溃会留下「keyring 说当前是新钥，但数据还是旧钥密文」
// 的状态 —— 而旧钥已不在环里可自动恢复，等于数据全丢。
//
// ## 用法
//
// homed-key-rotate -data /var/lib/homeagent -new-key <64位hex>
// homed-key-rotate -data /var/lib/homeagent -gen # 生成一把新钥并打印
//
// 轮换后**必须重启 homed**（密钥在启动时装配）。
package main
import (
"crypto/rand"
"encoding/hex"
"flag"
"fmt"
"os"
"path/filepath"
"github.com/JianFeeeee/HomeAgent/internal/config"
"github.com/JianFeeeee/HomeAgent/internal/security"
)
func main() {
dataDir := flag.String("data", "", "数据目录（config.db 所在处）")
newKeyHex := flag.String("new-key", "", "新主密钥（64 位 hex）；与 -gen 二选一")
gen := flag.Bool("gen", false, "生成一把新主密钥并打印（不执行轮换）")
flag.Parse()
if *gen {
k := make([]byte, 32)
if _, err := rand.Read(k); err != nil {
fail("生成密钥失败: %v", err)
}
fmt.Println(hex.EncodeToString(k))
return
}
if *dataDir == "" || *newKeyHex == "" {
fail("必须给 -data 与 -new-key（或 -gen 生成一个）")
}
// ① 先取当前钥（走与 homed 完全相同的优先级，避免拿错钥）
oldKey, src, err := security.LoadOrCreateKey(*dataDir)
if err != nil {
fail("读取当前主密钥失败: %v", err)
}
newKey, err := hex.DecodeString(*newKeyHex)
if err != nil || len(newKey) != 32 {
fail("-new-key 必须是 64 位 hex（32 字节）")
}
if string(newKey) == string(oldKey) {
fail("新钥与当前钥相同，无需轮换")
}
history, err := security.LoadKeyring(*dataDir, oldKey)
if err != nil {
fail("读取密钥环失败: %v", err)
}
fmt.Printf("当前密钥来源: %s（历史密钥 %d 把）\n", src, len(history))
// ② 重加密变量库
st := security.New(security.Options{
Path: filepath.Join(*dataDir, "security", "variables.json"),
KeyFn: func() ([]byte, error) { return oldKey, nil },
OldKeys: history,
Enabled: true,
})
if err := st.Load(); err != nil {
fail("加载变量库失败（不静默重建）: %v", err)
}
n := st.Count()
if err := st.RotateKey(newKey); err != nil {
fail("变量库轮换失败（数据未改动）: %v", err)
}
fmt.Printf("① 变量库已重加密（%d 条）\n", n)
// ③ 写 keyring（旧钥转为只读历史）。放在数据重加密之后 —— 见文件头说明。
if err := security.RotateKeyFile(*dataDir, oldKey, newKey); err != nil {
fail("写密钥环失败（变量库已是新钥，此时不可回退）: %v", err)
}
fmt.Printf("② 密钥环已更新（%s）\n", filepath.Join(*dataDir, security.KeyringFileName))
// 当前钥来源若是开发/磁盘路径，必须同步替换 security.key；否则下次启动
// LoadOrCreateKey 仍读旧钥，而 keyring current 已是新钥，会按设计响亮拒绝启动。
// systemd credential/env 不能由此命令擅自改：必须由运维更新注入源。
if src == filepath.Join(*dataDir, security.KeyFileName) {
path := filepath.Join(*dataDir, security.KeyFileName)
tmp := path + ".tmp"
if err := os.WriteFile(tmp, []byte(hex.EncodeToString(newKey)), 0o600); err != nil {
fail("更新磁盘主密钥失败: %v", err)
}
if err := os.Chmod(tmp, 0o600); err != nil {
fail("确权新主密钥失败: %v", err)
}
if err := os.Rename(tmp, path); err != nil {
fail("替换磁盘主密钥失败: %v", err)
}
fmt.Printf("③ 磁盘主密钥已替换（%s）\n", path)
} else {
fmt.Printf("③ 当前钥来自 %s：请先更新该注入源为新钥，再重启 homed\n", src)
}
if _, err := security.InitConfigCodecWithOldKeys(newKey, append([][]byte{oldKey}, history...)); err != nil {
fail("装配新配置 codec 失败: %v", err)
}
reg := config.NewConfigRegistry(filepath.Join(*dataDir, "config.db"))
defer reg.Close()
rekeyed, failed, err := reg.RekeySecrets()
if err != nil {
fail("config.db 重加密失败: %v", err)
}
fmt.Printf("③ config.db 已重加密 %d 条（失败 %d 条）\n", rekeyed, failed)
if failed > 0 {
fmt.Fprintf(os.Stderr, "⚠ 有 %d 条密文用新旧钥都解不开 —— 那说明它们来自更早的密钥，\n"+
" 请检查 security.keyring 的 history 是否完整（不要在此状态下删除旧钥）\n", failed)
}
fmt.Println("\n完成。请重启 homed 以使新密钥生效：systemctl restart homeagent.service")
}
func fail(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "错误: "+format+"\n", args...)
os.Exit(1)
}

5
cmd/homed-media-backfill/main.go
View File

@ -7,8 +7,9 @@
// 把字节搬进块，否则 CAS 目录一删，BlockData 就取不到字节（图永久丢失）。
//
// ★ 本命令**不 import internal/memory/media**：那个包正是要删掉的。
// 迁移工具只读**冻结的历史格式**：blobs/<digest[:2]>/<digest[2:]>。
// 依赖待删代码的迁移工具会在删包那一刻失效 —— 迁移必须比被迁移的东西活得久。
//
// 迁移工具只读**冻结的历史格式**：blobs/<digest[:2]>/<digest[2:]>。
// 依赖待删代码的迁移工具会在删包那一刻失效 —— 迁移必须比被迁移的东西活得久。
//
// 存量事实（生产 /home/newqqagent/memory）：
// - graph.db 有 112 个媒体块，引 106 个唯一 digest

721
cmd/homed/bootstrap.go
View File

@ -13,71 +13,21 @@ import (
"syscall"
"time"
agentPkg "github.com/JianFeeeee/HomeAgent/internal/agent"
agentAPI "github.com/JianFeeeee/HomeAgent/internal/agent/api"
agentCore "github.com/JianFeeeee/HomeAgent/internal/agent/core"
agentIO "github.com/JianFeeeee/HomeAgent/internal/agent/io"
internalConfig "github.com/JianFeeeee/HomeAgent/internal/config"
"github.com/JianFeeeee/HomeAgent/internal/events"
"github.com/JianFeeeee/HomeAgent/internal/ipc"
"github.com/JianFeeeee/HomeAgent/internal/knowledge"
logpkg "github.com/JianFeeeee/HomeAgent/internal/log"
luapkg "github.com/JianFeeeee/HomeAgent/internal/lua"
"github.com/JianFeeeee/HomeAgent/internal/memory"
"github.com/JianFeeeee/HomeAgent/internal/memory/distill"
"github.com/JianFeeeee/HomeAgent/internal/memory/document"
"github.com/JianFeeeee/HomeAgent/internal/memory/pipeline"
"github.com/JianFeeeee/HomeAgent/internal/memory/social"
"github.com/JianFeeeee/HomeAgent/internal/memory/text"
"github.com/JianFeeeee/HomeAgent/internal/memory/vector"
"github.com/JianFeeeee/HomeAgent/internal/nlp"
"github.com/JianFeeeee/HomeAgent/internal/plugin"
"github.com/JianFeeeee/HomeAgent/internal/recovery"
sdk "github.com/JianFeeeee/HomeAgent/internal/sdk"
safeclose "github.com/JianFeeeee/HomeAgent/internal/safeclose"
"github.com/JianFeeeee/HomeAgent/internal/supervisor"
"github.com/JianFeeeee/HomeAgent/internal/tracker"
"github.com/JianFeeeee/HomeAgent/pkg/embedding"
"github.com/JianFeeeee/HomeAgent/pkg/generation"
"github.com/JianFeeeee/HomeAgent/pkg/types"
)
// defaultSystemPrompt 是内置默认人格模板：不含版本号字面量，
// 被问版本时以运行时快照为准（历史上写死版本号导致实例自称旧版本）。
const defaultSystemPrompt = `你是 HomeAgent，一个持续运行的个人管家。
你的每次回复会自动发送到当前输出通道（默认=输入源），无需额外工具。
如需切换回复通道，使用 output_set_channel。
如需异步发送消息或通知，使用 output_send 指定通道和内容。
使用 output_list_channels 查看可用通道及其能力。
可用工具列表会由系统自动传入，按需使用即可。以下是你尤其需要关注的几类工具：
- memory_* — 图记忆（长期记忆，记录和查询个人信息/事实）
- knowledge_* — 知识库（查阅预设知识文档）
- doc_* — 文档记忆（近期对话的存档，查询后自动清除）
- person_* — 人物特质与社交关系网
- llm_* — LLM 源管理（列出/切换模型提供商）
- output_* — 输出通道管理（切换/发送消息）
- timer_set — 设置定时提醒
- plgreload — 热重载插件
- spawn_child — 生成子 Agent 异步执行独立任务（可传 max_turns 控制工具轮数，默认 5）
并行策略：遇到多个互不依赖的子任务时，优先并行 spawn 多个子 Agent 而非自己串行逐个执行；
长耗时任务（批量处理、多轮搜索汇总）也应交给子 Agent，避免阻塞当前对话。
- describe_image — 描述用户上传的图片
- transcribe_audio — 转写用户上传的音频
- ocr_image — 识别图片中的文字
命令与文件操作策略：
- cmd_run 经完整 shell（bash）执行，支持管道、分号、&&、命令替换、heredoc、重定向。
- 多步交互式程序（vim/top/ssh 会话、需要持续输入的进程）用 terminal_create 创建终端，
terminal_write 发送输入、terminal_read 读输出——不要用 cmd_run 硬等交互程序退出。
- 写文件优先 files_write（原子+留档），生成多行内容时可用 heredoc 或 files_write，
不要用 echo 拼接长文本。
- 读用户发来的文件用 files_read；向 webui 回传图片/文件用 output_send__webui(type=image/file)。
当用户上传图片或音频时，系统会自动附着媒体内容。如果模型不支持直接处理多媒体，请使用上述工具。
回复你的真实想法，用自然语言与用户交流。不要在回复中使用 emoji 表情。`
// setupLogging 初始化日志：行号前缀 + 同时输出到控制台与 <data>/log/ 下的本次启动文件。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
@ -136,564 +86,6 @@ type memoryStack struct {
distiller *pipeline.Distiller
}
// initMemoryStack 初始化图记忆 / 索引 / 社交图 / 蒸馏管线。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initMemoryStack(dataDir string, cfgReg *internalConfig.ConfigRegistry) (*memoryStack, func()) {
memDB, err := memory.NewGraphDB(filepath.Join(dataDir, "memory", "graph.db"))
if err != nil {
log.Printf("[homed] warning: memory init failed: %v", err)
memDB = nil
} else {
log.Printf("[homed] graph memory initialized")
}
memIdx := memory.NewIndexer(memDB)
memIdx.Sync() // 启动时立即同步，避免前30分钟空窗
socialStore := social.New(memDB)
distiller := pipeline.NewDistiller(memDB, dataDir, pipeline.DistillerConfig{
Interval: 10 * time.Minute,
RetentionDays: 7,
BatchSize: 50,
})
// ★ 必须在 distiller.Start() **之前**注入：Start 会起 distillLoop，
// 而第一次 tick 在 Interval 之后。若先 Start 再注入，头一个周期
// （实测配置 10 分钟）会白跑一次 jieba 路 —— 而那条路实测产出 0 条。
if memDB != nil {
distiller.SetSplitter(initDistillSplitter(cfgReg))
}
if memDB != nil {
// 这里**故意不写 defer distiller.Stop()**：本函数在 return 时即触发
// defer，而 Stop() → cancel() 会让刚启动的 distillLoop 立刻退出，
// 规则蒸馏管线启动即死、10min 心跳从不运行（旧 main() 拆分时的残留）。
// 停机由调用点注册的 cleanup 负责（见下方返回值）。
distiller.Start()
}
return &memoryStack{db: memDB, indexer: memIdx, social: socialStore, distiller: distiller},
func() {
// 与原 main 的两个 defer 同序（LIFO）：先停蒸馏器，再关图库。
if memDB != nil {
distiller.Stop()
}
if memDB != nil {
memDB.Close()
}
}
}
// startMemoryCandidateConsumer 起一个常驻 goroutine：把 eventbus 上的 memory_candidate 事件写进文本记忆并喂给蒸馏管线。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func startMemoryCandidateConsumer(ctx context.Context, iom *agentIO.IOManager, textMem *text.Memory, memDB *memory.GraphDB, distiller *pipeline.Distiller) {
go func() {
for {
select {
case <-ctx.Done():
return
case evt, ok := <-iom.OutputChan():
if !ok {
return
}
if evt.Target == "memory" && evt.Type == "memory_candidate" {
source, _ := evt.Payload["source"].(string)
input, _ := evt.Payload["input"].(string)
response, _ := evt.Payload["response"].(string)
toolsUsed, _ := evt.Payload["tools_used"].([]string)
toolResults, _ := evt.Payload["tool_results"].([]interface{})
agentID, _ := evt.Payload["agent_id"].(string)
if input != "" && textMem != nil {
te := text.Event{
Timestamp: time.Now().Unix(),
Source: source,
Input: input,
Response: response,
ToolsUsed: toolsUsed,
AgentID: agentID,
}
if err := textMem.Append(te); err != nil {
log.Printf("[homed] text memory append: %v", err)
}
}
if input != "" && memDB != nil {
distiller.Append("agent", "user", input)
}
if response != "" && memDB != nil {
distiller.Append("agent", "assistant", response)
}
// 工具输出接入蒸馏管线
for _, tr := range toolResults {
if trMap, ok := tr.(map[string]interface{}); ok {
if text, ok := trMap["output"].(string); ok && text != "" && memDB != nil {
distiller.Append("agent", "tool", text)
}
}
}
}
}
}
}()
}
// initLLMProviders 按配置注册全部 LLM 源（每个源经 Lua 适配器协议转换），并把各适配器的并发额度汇总回 Lua VM。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initLLMProviders(cfg *types.Config, luaVM *luapkg.VM, baseAPIKey string) *agentAPI.ProviderManager {
providerMgr := agentAPI.NewProviderManager()
adapterConcurrency := map[string]int{}
for _, src := range cfg.LLM.Sources {
if !agentAPI.IsValidSourceConfig(src.Name, src.BaseURL, src.Model, src.Adapter) {
log.Printf("[homed] skip invalid llm source %q (base_url=%q model=%q adapter=%q)", src.Name, src.BaseURL, src.Model, src.Adapter)
continue
}
key := src.APIKey
if key == "" {
key = baseAPIKey
}
luaProvider := agentAPI.NewLuaAdaptedProvider(agentAPI.BaseConfig{
Model: src.Model,
BaseURL: src.BaseURL,
APIKey: key,
Temperature: cfg.LLM.Temperature,
MaxTokens: cfg.LLM.MaxTokens,
ContextWindow: src.ContextWindow,
MaxConcurrent: src.MaxConcurrent,
Priority: src.Priority,
Vision: src.Vision,
Audio: src.Audio,
}, luaVM, src.Name, src.Adapter)
providerMgr.Register(src.Name, luaProvider)
if src.Adapter != "" {
adapterConcurrency[src.Adapter] += src.MaxConcurrent
}
}
luaVM.ConfigureConcurrency(adapterConcurrency)
if cfg.LLM.Provider != "" {
providerMgr.SetDefault(cfg.LLM.Provider)
}
return providerMgr
}
// initDocStore 启动文档记忆。flush 的唯一入口是 Stop()，所以关停时必须调用它。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initDocStore(cfg *types.Config) (*document.Store, func()) {
docStore := document.NewStore(filepath.Join(cfg.Daemon.DataDir, "memory", "documents"), memory.TokenizeWords)
if err := docStore.Start(); err != nil {
log.Printf("[homed] warning: document store: %v", err)
}
// 关停时落盘。文档记忆的内存态变更（迁移结果、访问计数等）只在 flush
// 里写盘，而 flush 的唯一入口是 Stop()——此前全仓无人调用它，
// 于是迁移结果永不落盘、每次启动白算一遍。
return docStore, func() { docStore.Stop() }
}
// initDistillSplitter 按配置打开蒸馏用的生成侧 provider 并组装拆分器。
//
// 返回 nil 表示不启用（未配置 provider、或打开失败）—— 此时蒸馏回退既有的
// jieba/ONNX 路。**不因为模型不可用而让蒸馏停摆**：那条路虽然实测产出 0 条，
// 但它至少不会让对话记忆丢失。
//
// 配置形态与多模态向量侧对称（core.memory.multimodal_space.*）：
//
// core.memory.distill.generation.provider = ollama
// core.memory.distill.generation.options.model = qwen3:1.7b
// core.memory.distill.generation.options.num_thread = 10
func initDistillSplitter(cfgReg *internalConfig.ConfigRegistry) pipeline.RecordSplitter {
if cfgReg == nil {
return nil
}
providerName := cfgReg.GetString("core.memory.distill.generation.provider", "")
if providerName == "" {
return nil
}
opts := map[string]string{}
const optPrefix = "core.memory.distill.generation.options."
for _, key := range cfgReg.List(optPrefix) {
opts[strings.TrimPrefix(key, optPrefix)] = cfgReg.GetString(key, "")
}
provider, err := generation.Open(providerName, generation.Config{Options: opts})
if err != nil {
log.Printf("[homed] warning: 蒸馏生成 provider %q 打开失败: %v（蒸馏回退 jieba 路；已注册: %s）",
providerName, err, strings.Join(generation.Names(), ", "))
return nil
}
if !provider.Info().SupportsJSONSchema {
// 拆分器的零幻觉完全依赖 schema 约束。不支持 schema 的 provider
// 会拿到自由文本，解析必炸 —— 与其让它在运行时反复失败，不如现在就拒。
log.Printf("[homed] warning: 蒸馏生成 provider %q 不支持 JSON Schema，拆分不可靠（蒸馏回退 jieba 路）",
providerName)
provider.Close()
return nil
}
log.Printf("[homed] distill generation active: provider=%s model=%s",
providerName, provider.Info().Model)
return distill.NewExtractor(provider, nil)
}
// initMultimodalSpace 从公共注册表打开多模态向量 provider。返回 (空间, provider 名, 失败原因, cleanup)：后两个值只用于状态报告。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initMultimodalSpace(cfgReg *internalConfig.ConfigRegistry) (vector.MultimodalEmbedder, string, string, func()) {
var multimodalSpace vector.MultimodalEmbedder
// 这两个值只用于状态报告（healthcheck_kernel 的 onnx 段）：
// 「配了哪个 provider」与「为什么没启用」，避免只能看到 false 却不知原因。
var mmProviderName, mmErr string
var closeAdapted func()
if mmProvider := cfgReg.GetString("core.memory.multimodal_space.provider", ""); mmProvider != "" {
mmProviderName = mmProvider
opts := map[string]string{}
const optPrefix = "core.memory.multimodal_space.options."
for _, key := range cfgReg.List("core.memory.multimodal_space.options.") {
opts[strings.TrimPrefix(key, optPrefix)] = cfgReg.GetString(key, "")
}
provider, err := embedding.Open(mmProvider, embedding.Config{Options: opts})
if err != nil {
mmErr = err.Error()
log.Printf("[homed] warning: 多模态向量 provider %q 打开失败: %v（多模态向量检索已禁用；已注册: %s）",
mmProvider, err, strings.Join(embedding.Names(), ", "))
} else if adapted, err := vector.AdaptProvider(provider); err != nil {
provider.Close()
mmErr = err.Error()
log.Printf("[homed] warning: 多模态向量 provider %q 元数据不合法: %v（多模态向量检索已禁用）", mmProvider, err)
} else {
multimodalSpace = adapted
info := provider.Info()
// 指纹可能很长（模型文件哈希），日志里只取前 12 个字符便于对照。
shortFP := info.Fingerprint
if len(shortFP) > 12 {
shortFP = shortFP[:12]
}
log.Printf("[homed] multimodal space active: provider=%s dim=%d fp=%s modalities=%v",
mmProvider, info.Dimension, shortFP, info.Modalities)
}
}
if closeAdapted == nil {
closeAdapted = func() {}
}
return multimodalSpace, mmProviderName, mmErr, closeAdapted
}
// initKnowledgeStore 启动知识库。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initKnowledgeStore(cfg *types.Config) *knowledge.Store {
ks := knowledge.NewStore(filepath.Join(cfg.Daemon.DataDir, "knowledge"))
if err := ks.Start(); err != nil {
log.Printf("[homed] warning: knowledge store: %v", err)
} else {
log.Printf("[homed] knowledge store active with %d items", len(ks.List()))
}
return ks
}
// initKnowledgeMigration 在知识库扫盘**之前**把存量目录名规范化。
//
// 为何不靠 Store 内部自己做：规范名是「内存键 + 盘上目录 + LLM 可见名字」
// 三者必须逐字一致，而磁盘重命名属于有破坏性的副作用，应该在 store 扫盘
// 之前、在明确的边界上一次性做完，而不是散在 Store 的初始化路径里。
//
// 为何默认只报告：os.Rename 不可逆，批量重命名生产数据必须由人确认。
// 需要真正迁移时用 homed-kb-migrate -apply（或把下面 defaultApply 打开）。
//
// 本函数体同样遵守 bootstrap 的平移原则。
func initKnowledgeMigration(cfg *types.Config) {
root := filepath.Join(cfg.Daemon.DataDir, "knowledge")
const (
// defaultApply = false ⇒ 启动时只扫描并报告，不改名。
defaultApply = false
// maxRenamePerRun 限制单次重命名数：给失控的目录规模设一个上限，
// 避免启动阶段被一次大迁移拖住。
maxRenamePerRun = 200
)
items, err := knowledge.PlanMigration(root)
if err != nil {
log.Printf("[homed] 知识库迁移扫描失败（跳过）: %v", err)
return
}
need, illegal := 0, 0
for _, it := range items {
if it.Illegal {
illegal++
} else if it.NewName != "" {
need++
}
}
if need == 0 && illegal == 0 {
return
}
if illegal > 0 {
log.Printf("[homed] 知识库迁移：%d 条名称非法（含 .. / 点段 / 隐藏段），写入与删除均已拒绝，需人工处理", illegal)
}
if need == 0 {
return
}
log.Printf("[homed] 知识库迁移：%d/%d 条目录名待规范化（例：%s → %s）", need, len(items),
items[0].OldName, items[0].NewName)
if !defaultApply {
log.Printf("[homed] 知识库迁移：当前为只报告模式。确认清单后执行：homed-kb-migrate -root %s -apply", root)
return
}
if need > maxRenamePerRun {
log.Printf("[homed] 知识库迁移：需改名 %d 条超过单次上限 %d，本次只处理前 %d 条",
need, maxRenamePerRun, maxRenamePerRun)
}
applied, failed := knowledge.ApplyMigration(root, items, maxRenamePerRun)
log.Printf("[homed] 知识库迁移完成：成功 %d，失败 %d", applied, failed)
}
// loadPersonality 按「个人文件 > 配置项」的优先级解析人格内容，并对腐坏内容告警。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func loadPersonality(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry) *agentPkg.Personality {
personalPath := filepath.Join(cfg.Daemon.DataDir, "personal", "personal.md")
personality, err := agentPkg.LoadPersonality(personalPath)
if err != nil {
log.Printf("[homed] warning: load personality: %v", err)
}
if personality != nil && personality.Content != "" {
log.Printf("[homed] 人格来源=文件 %s（优先于配置项），%d 字节", personalPath, len(personality.Content))
if hints := agentPkg.PersonaStaleHints(personality.Content); len(hints) > 0 {
log.Printf("[homed] warning: 人格文件含会腐坏的内容 %v — 建议迁到配置项 core.agent.personal_prompt"+
"（默认模板不含版本号，被问版本时以运行时快照为准）", hints)
}
} else if pv := cfgReg.GetString("core.agent.personal_prompt", internalConfig.DefaultPersonaPrompt); strings.TrimSpace(pv) != "" {
personality = &agentPkg.Personality{Content: pv, Path: "(core.agent.personal_prompt)"}
log.Printf("[homed] 人格来源=配置项 core.agent.personal_prompt，%d 字节", len(pv))
} else {
log.Printf("[homed] 人格来源=无（配置项为空且无人格文件）")
}
return personality
}
// newStageAndRegistry 建阶段管道与插件注册表，把内核依赖接到注册表上。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func newStageAndRegistry(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry, iom *agentIO.IOManager,
evBus *events.Bus, memDB *memory.GraphDB, textMem *text.Memory, docStore *document.Store,
ks *knowledge.Store, providerMgr *agentAPI.ProviderManager,
dataDir string) (*agentCore.StageHost, *plugin.Registry) {
stageHost := agentCore.NewStageHost()
pluginReg := plugin.NewRegistry()
pluginReg.SetIOManager(iom)
pluginReg.SetEventBus(evBus)
pluginReg.SetMemory(memDB)
pluginReg.SetTextMemory(textMem)
pluginReg.SetDocStore(docStore)
pluginReg.SetKnowledge(ks)
pluginReg.SetProviderManager(providerMgr)
pluginReg.SetConfigRegistry(cfgReg)
pluginReg.SetPluginDir(cfg.Plugin.Dir)
pluginReg.SetDataDir(dataDir) // 插件 SettingsAPI.DataDir() 的数据根目录
// Wire registration callbacks: plugins' RegisterTool/RegisterStage → StageHost
pluginReg.SetToolRegistrar(func(name string, def sdk.ToolDef, handler sdk.ToolHandler) error {
log.Printf("[homed] SetToolRegistrar registering tool: %s (plugin=%s)", name, def.Plugin)
return stageHost.RegisterTool(name, def, handler)
})
pluginReg.SetStageRegistrar(func(stage sdk.Stage, handler sdk.StageHandler) {
stageHost.RegisterStage(stage, handler)
})
pluginReg.SetAPIRegistrar(func(name string) error {
return nil
})
pluginReg.SetToolCleaner(stageHost)
return stageHost, pluginReg
}
// newMainAgent 组装主 Agent：把内核各面（IO/记忆/文档/知识/媒体/社交/文本/插件/状态）接进 AgentConfig。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func newMainAgent(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry, provider agentAPI.Provider,
providerMgr *agentAPI.ProviderManager, iom *agentIO.IOManager, memDB *memory.GraphDB,
memIdx *memory.Indexer, trk *tracker.Tracker, docStore *document.Store, ks *knowledge.Store,
socialStore *social.SocialStore, textMem *text.Memory,
personality *agentPkg.Personality, pluginReg *plugin.Registry, embedder *memory.StaticEmbedder,
multimodalSpace vector.MultimodalEmbedder, mmProviderName, mmErr string,
stageHost *agentCore.StageHost, evBus *events.Bus) *agentCore.Agent {
sysPrompt := cfgReg.GetString("core.agent.system_prompt", defaultSystemPrompt)
if sysPrompt == "" {
sysPrompt = defaultSystemPrompt
}
// D4：把"设备是否已授权"的判据注入插件侧（toolImpl.CanUse 用）。
// ⚠️ 必须放在 agent 构造**之后**——判据要用 agent 的 allowedOutputs，
// 而 registry 早于 agent 构造（故这里传的是晚绑定闭包）。
// 未注入时 ToolAPI 路径对设备放行：那是"授权可被绕过"的既成缺口。
// 注入后，cli 的 /terminal、seq 序列等一切走 ToolAPI 的调用都受同一道闸。
agent := agentCore.New(agentCore.AgentConfig{
ID: "main",
SystemPrompt: sysPrompt,
Provider: provider,
ProviderManager: providerMgr,
IO: iom,
Memory: memDB,
Indexer: memIdx,
Tracker: trk,
DocStore: docStore,
Knowledge: ks,
SocialStore: socialStore,
TextMemory: textMem,
// MediaStore 已随 CAS 淘汰：块自带负载（见 plan.md）。
Personality: personality,
// 人格落库面：首启门禁（任何通道都问一次）与 persona_set 工具用。
// 与 WebUI 向导共用 internal/config 的同一份落库逻辑。
PersonaStore: internalConfig.RegistryPersonaStore{Reg: cfgReg},
PluginReg: pluginReg,
PluginDir: cfg.Plugin.Dir,
// DataDir：驻留子的 temp 图库锚点（<data>/residents/<id>/graph.db）。
// 漏接时的现象是"工具存在、可调用、但创建必失败"——只有真实二进制才看得出来。
DataDir: cfg.Daemon.DataDir,
DistillInterval: cfgReg.GetDuration("core.agent.distill_interval", 30*time.Minute),
ArchiveInterval: cfgReg.GetDuration("core.agent.archive_interval", 60*time.Minute),
ReviewInterval: cfgReg.GetDuration("core.agent.review_interval", 120*time.Minute),
MergeInterval: cfgReg.GetDuration("core.agent.merge_interval", 120*time.Minute),
MaxToolTurns: cfgReg.GetInt("core.agent.max_tool_turns", 10),
// 上下文管理的可调阈值。此前这些值全部硬编码在 ComputeTokenBudget 里，
// 界面改不了、不同窗口的实例也没法各自调优。
CtxTuning: agentCore.ContextTuning{
UtilizationPercent: cfgReg.GetInt("core.agent.context.utilization_percent", 80),
MaxTargetTokens: cfgReg.GetInt("core.agent.context.max_target_tokens", 600000),
MemoryRatioPercent: cfgReg.GetInt("core.agent.context.memory_ratio_percent", 0),
ProtectedCount: cfgReg.GetInt("core.agent.context.protected_count", 10),
},
// ⚠️ 这条键此前被注册进配置面板、也有默认值，但**从未被读取** ——
// 界面上改它没有任何效果，且不报任何错。同一类「死配置」正是
// 本次把阈值接入配置系统时要一并修掉的。
MaxContextSize: cfgReg.GetInt("core.agent.max_context_size", 30),
Offload: agentCore.OffloadOptions{
Enabled: cfgReg.GetBool("core.agent.offload_enabled", false),
BusyAfter: cfgReg.GetDuration("core.agent.offload_busy_after", 5*time.Minute),
MinPending: cfgReg.GetInt("core.agent.offload_min_pending", 3),
MaxResidents: cfgReg.GetInt("core.agent.offload_max_residents", 2),
},
ContextSavePath: filepath.Join(cfg.Daemon.DataDir, "memory", "context.json"),
EmbeddingModelPath: cfgReg.GetString("core.agent.embedding_model_path", ""),
Embedder: embedder,
MultimodalSpace: multimodalSpace,
EmbeddingProvider: mmProviderName,
EmbeddingError: mmErr,
StageHost: stageHost,
EventBus: evBus,
ThinkingEnabled: cfg.LLM.ThinkingEnabled,
InputProcessing: cfg.InputProcessing,
})
// 图记忆读写钩子 → 事件总线。
//
// ★ 为什么在这里接（而不是让各调用方自己发事件）：
// 图读写散在 26 个方法与 180+ 个 db 调用点上，各调用方自报必漏发；
// 而**图库自己就知道它碰了哪些块 ID**。星图此前只能靠工具名猜
// 节点（把 "memory_recall" 拆词去匹配中文实体名，实测命中 0），
// 于是每次都点亮同一批无关节点——这正是「星图没有读写反馈」的真身。
//
// ★ 只在 evBus 非 nil 时接：它把「内核进程」与「独立 CLI 工具」区分开
// （homed-graph-migrate / memgc 等也用 NewGraphDB，但没有事件总线，
// 也不该为一次批量迁移向不存在的订阅者发几万条事件）。
//
// ★ 钩子**必须非阻塞**：它在记忆读写的同步路径上，发布到总线
// 是内存操作（各订阅者回调也都很短），实测开销可忽略。
if memDB != nil && evBus != nil {
memDB.SetAccessHook(func(ev memory.AccessEvent) {
payload := map[string]interface{}{
"op": ev.Op,
}
// 只在非空时带上字段：空数组会让前端白白重算一次。
if len(ev.Blocks) > 0 {
payload["blocks"] = ev.Blocks
}
if len(ev.Created) > 0 {
payload["created"] = ev.Created
}
if len(ev.Removed) > 0 {
payload["removed"] = ev.Removed
}
if len(ev.Merged) > 0 {
merged := make([]map[string]string, 0, len(ev.Merged))
for _, m := range ev.Merged {
merged = append(merged, map[string]string{"from": m.From, "to": m.To})
}
payload["merged"] = merged
}
if ev.Tool != "" {
payload["tool"] = ev.Tool
}
evBus.Publish(&events.Event{
Type: events.EventMemoryAccess,
Source: "main",
Payload: payload,
Timestamp: time.Now().Unix(),
})
})
}
// D4：把「设备是否已授权」的判据注入插件侧（toolImpl.CanUse 消费它）。
//
// 为什么必须在这里：判据要用 agent 自己的 allowedOutputs，而
// pluginReg 早于 agent 构造（newStageAndRegistry 在 main() 里先跑），
// 所以 registry 存的是**晚绑定**闭包，注入点必须在 agent 建好之后。
//
// 不注入的后果（已实测的真实缺口）：设备授权闸只存在于
// core.executeToolCallInner，即「agent 收到模型 tool_call」那条路径；
// 而 ToolAPI.ExecuteTool 是**另一条**独立入口，不经那道闸 ⇒
// 凡是走 ToolAPI 的调用都能绕过 AllowedOutputs。实测范围不止序列：
// cli 的 /terminal 就直接经 ToolAPI 调 agentcli 的终端工具。
pluginReg.SetDeviceAuthQuery(func(deviceID string) bool {
return agent.IsOutputAllowed("device/" + deviceID)
})
// 方案 B：把 agent 的**内置工具面**注入 ToolAPI。
//
// 缺口背景：`memory_*` / `knowledge_*` / `doc_*` / `person_*` 这 20+ 个
// 在 executeToolCallInner 里按前缀分派，从不进 ToolAPI ⇒ 插件经 ToolAPI
// 既查不到也调不了。真机实跑实证：seq_run 报「工具 knowledge_list
// 不存在或未注册」，而同一轮模型直接调它是成功的。
//
// 注入必须在此处（agent 构造之后）：内置工具的可见性由运行期状态门控
// （memory/knowledge 是否就绪），而 provider 持有的是 agent。
agent.InstallBuiltinToolProvider()
return agent
}
// initONNXParser 初始化依存句法分析器（内嵌 ONNX 模型，失败则退回规则引擎）。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func initONNXParser(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry) {
modelPath := cfgReg.GetString("core.agent.onnx_model_path", "")
onnxParser, err := nlp.NewONNXParser(nlp.ONNXConfig{
ModelPath: modelPath,
DataDir: filepath.Join(cfg.Daemon.DataDir, "nlp"),
})
if err != nil {
log.Printf("[homed] warn: ONNX parser init: %v, using fallback", err)
} else {
nlp.SetDefaultParser(onnxParser)
log.Printf("[homed] dep parser initialized (model: %s)", modelPath)
}
}
// loadPlugins 建插件目录、按启动模式决定 allowlist，然后加载全部插件。
//
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
@ -865,7 +257,27 @@ func startHeartbeat(dataDir string, ctx context.Context) func() {
}
}()
return func() { close(hbStop) }
// ★★ 必须幂等（2026-10-17 实测 panic：close of closed channel）。
//
// 调用点有**两处**：
// · main.go:70 `defer stopHeartbeatEarly()`
// · bootstrap.go waitForShutdown 里的 `stopHeartbeat()`
// 直接 `close(hbStop)` ⇒ 第二次关闭**必然 panic**：
//
// panic: close of closed channel
// goroutine 1 [running]:
// main.startHeartbeat.func3() bootstrap.go:259
// main.main() main.go:293
//
// 而且它发生在**退出路径**上：进程已经做完清理工作，
// 却在最后一步崩溃 ⇒ 退出码变成 2（panic），
// systemd/guard 会把它当成"异常退出"而不是"正常停止"，
// 进而触发不必要的重启/告警。实测：SIGTERM 后退出但日志尾部是 panic 栈。
//
// 修法：`sync.Once` 保护。stop 函数做成幂等是本仓退出路径的通用要求
// （它们往往既被 defer 调、又被显式调）。
// 用 safeclose 统一入口（本仓 close 纪律：见 internal/safeclose）。
return safeclose.SafeFunc(hbStop)
}
// waitForShutdown 阻塞至 SIGINT/SIGTERM 或 supervisor 请求重启，然后按原 main 的顺序清理，需要重建时以退出码交回 guard。
@ -873,7 +285,8 @@ func startHeartbeat(dataDir string, ctx context.Context) func() {
// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
func waitForShutdown(ctx context.Context, dataDir string, restartCh chan struct{}, stopHeartbeat func(),
pluginReg *plugin.Registry, trk *tracker.Tracker, cfgReg *internalConfig.ConfigRegistry, sup *supervisor.Daemon) {
pluginReg *plugin.Registry, trk *tracker.Tracker, cfgReg *internalConfig.ConfigRegistry, sup *supervisor.Daemon,
stopKernelModules func()) {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
@ -895,6 +308,21 @@ func waitForShutdown(ctx context.Context, dataDir string, restartCh chan struct{
log.Printf("[homed] flush config: %v", err)
}
sup.Shutdown()
// ★★ 必须显式跑一次模块关闭，**不能只靠 defer**（2026-10-17 实测缺陷）。
//
// 两条退出路径原先**不对称**：
// 路径 A（SIGTERM）：return 到 main → defer ks.CloseAll() ✓
// 路径 B（exit 42）：下面的 os.Exit(42) **跳过所有 defer** ✗
//
// 而路径 B 是**每次热更新都走**的。后果是这些写者从不 flush：
// · docStore.Stop() → flush() 文档索引可能陈旧
// · distiller.Stop() → flush() 待蒸馏规则丢失
// · textMem.Stop() → Close() 文本记忆未落盘
// · luaVM/multimodal → 资源未释放（靠进程退出兜底）
//
// ⇒ 显式调用（CloseAll 幂等：第二次执行时 Closers 已空，无副作用）。
stopKernelModules()
log.Printf("[homed] stopped")
if restartRequested {
@ -902,62 +330,6 @@ func waitForShutdown(ctx context.Context, dataDir string, restartCh chan struct{
}
}
// initLuaVM 起 Lua VM（LLM 协议适配）；启动失败只告警，cleanup 为 no-op。
func initLuaVM(cfg *types.Config) (*luapkg.VM, func()) {
luaVM := luapkg.NewVM(filepath.Join(cfg.Daemon.DataDir, "adapters"))
if err := luaVM.Start(); err != nil {
log.Printf("[homed] warning: lua vm init failed: %v", err)
return luaVM, func() {}
}
return luaVM, luaVM.Stop
}
// initSupervisor 起守护管理（代理生命周期管理）；起不来是致命错误。
func initSupervisor(cfg *types.Config) *supervisor.Daemon {
sup := supervisor.New(cfg)
if err := sup.Start(); err != nil {
log.Fatalf("start supervisor: %v", err)
}
return sup
}
// initTracker 起 overlayfs 变更追踪；无 overlayfs 支持时降级为非致命告警。
func initTracker(cfg *types.Config, agentWorkDir string) *tracker.Tracker {
trk := tracker.NewTracker(cfg.Daemon.DataDir, agentWorkDir,
tracker.WithKeepChangesets(100),
tracker.WithMaxChangesetAge(30*24*time.Hour),
)
if err := trk.Init(); err != nil {
log.Printf("[homed] warning: tracker init: %v", err)
} else {
if err := trk.Start(); err != nil {
log.Printf("[homed] warning: tracker mount overlay: %v (non-fatal: no overlayfs support?)", err)
} else {
log.Printf("[homed] change tracker active at %s", trk.MergeDir())
}
}
return trk
}
// initKernelAPI 建内核与插件之间的两个通道：IOManager（IO 抽象层）+ EventBus（事件总线）。
func initKernelAPI() (*agentIO.IOManager, *events.Bus) {
iom := agentIO.NewIOManager()
evBus := events.NewBus()
log.Printf("[homed] kernel API ready: IOManager + EventBus")
return iom, evBus
}
// initTextMemory 起文本记忆；启动失败只告警，cleanup 为 no-op。
func initTextMemory(cfg *types.Config) (*text.Memory, func()) {
textMem := text.New(filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
if err := textMem.Start(); err != nil {
log.Printf("[homed] warning: text memory start: %v", err)
return textMem, func() {}
}
log.Printf("[homed] text memory active at %s", filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
return textMem, textMem.Stop
}
// resolveBaseAPIKey 解析兜底 API key：配置项 > LLM_API_KEY > DEEPSEEK_API_KEY。
func resolveBaseAPIKey(cfg *types.Config) string {
apiKey := cfg.LLM.APIKey
@ -970,21 +342,6 @@ func resolveBaseAPIKey(cfg *types.Config) string {
return apiKey
}
// wirePluginSDK 把内核各面注入每个插件的 PluginSDK（阶段6 将替换遗留的 util.Configure）。
func wirePluginSDK(pluginReg *plugin.Registry, luaVM *luapkg.VM, baseAPIKey string, sup *supervisor.Daemon,
trk *tracker.Tracker, cfg *types.Config, stageHost *agentCore.StageHost, memIdx *memory.Indexer,
agent *agentCore.Agent) {
pluginReg.SetLuaVM(luaVM)
pluginReg.SetBaseAPIKey(baseAPIKey)
pluginReg.SetSupervisor(supervisor.NewSDKAdapter(sup))
pluginReg.SetTracker(trk)
pluginReg.SetConfig(cfg)
pluginReg.SetStageHost(stageHost)
pluginReg.SetIndexer(memIdx)
pluginReg.SetStatusProvider(agent)
pluginReg.SetTerminalAPI(agent)
}
// resolveWebUIOverride 解析 webui 监听地址的覆盖值，空串表示不覆盖。
//
// 优先级：CLI --webui > 核心配置 webui.listen_addr（仅当它被改成非内置默认值）。

126
cmd/homed/bootstrap_order_test.go Normal file
View File

@ -0,0 +1,126 @@
package main
// 启动顺序的**结构性判据**（2026-10-16）。
//
// ## 为什么必须有这条
//
// 实测故障（我方引入）：安全模块原先装配在 `cfg := cfgReg.ToConfig()` **之后**。
// 于是 `ToConfig()` 在**没有主密钥**的情况下读 `core.llm.*.api_key` ——
// 密文解不开 ⇒ key 变成空串；而 `initLLMProviders(cfg, …)` 用的正是这份
// 早期快照 ⇒ **所有 LLM 调用 401 invalid api key**。
//
// 症状极具误导性：日志里只有 `Dump 解密 core.llm.api_key 失败: security: 无可用主密钥`，
// 而 401 看起来像"key 配错了"。实际是纯粹的**启动顺序**问题 ——
// 查 key 值、改 key、重配 provider 全都无效。
//
// ## 为什么用行号比较而不是行为测试
//
// `main()` 无法在单测里跑（要完整数据目录、要真密钥、要起一堆子系统）。
// 而这里要守的是一个**结构性不变量**：「安全模块的装配点必须早于配置快照点」。
// 行号比较恰好精确表达这个不变量 —— 比字符串包含匹配强得多
// （后者在"注释里提到 ToConfig"时就会假绿或假红）。
//
// 这是本仓"判据要测真实顺序，而不是测某个字符串出现过"的一个正例：
// 判据断言的是**两个真实调用点的相对位置**。
import (
"os"
"strings"
"testing"
)
// ★★★ 判据：安全模块（InitConfigCodec）必须装配在 cfg := cfgReg.ToConfig() 之前。
//
// 违反的后果：LLM key 解不开 ⇒ 全 provider 401，而症状指向"key 配错"。
func TestSecurityModuleInitializesBeforeConfigSnapshot(t *testing.T) {
b, err := os.ReadFile("main.go")
if err != nil {
t.Fatalf("读不到 main.go: %v", err)
}
src := string(b)
// 找**真实的调用点**：行内出现调用名，且该行不是注释。
//
// 为什么用 Contains 而不是 HasPrefix：真实形式有三种
// cfg := cfgReg.ToConfig()
// if _, cerr := security.InitConfigCodecWithOldKeys(...); cerr != nil {
// key, keySrc, kerr := security.LoadOrCreateKey(...)
// 用 HasPrefix 会漏掉 if/赋值形态（第一版就是这么漏的）。
// 注释行仍要排除 —— 否则本文件顶部的说明注释会被当成装配点。
lineOf := func(call string) int {
for i, ln := range strings.Split(src, "\n") {
t := strings.TrimSpace(ln)
if strings.HasPrefix(t, "//") {
continue
}
if strings.Contains(ln, call) {
return i + 1
}
}
return -1
}
// ★ 锚点已随"内核模块化"改写（2026-10-16）：
// `cfg := cfgReg.ToConfig()` → `ks.Cfg = cfgReg.ToConfig()`
// （快照现在直接存进 KernelState 的公共结构体，用户设计要求）。
//
// ★ 为什么匹配 "cfgReg.ToConfig()" 而不是整行：
// 赋值目标从 `cfg` 变成了 `ks.Cfg`，将来还可能再变。
// 判据要守的是**"ToConfig() 这个调用点的相对位置"**，
// 而不是某次具体的赋值写法 —— 锚在调用名上更稳且仍是真实调用点
// （lineOf 已排除注释行）。
snapLine := lineOf("cfgReg.ToConfig()")
if snapLine < 0 {
t.Fatal("找不到 `cfgReg.ToConfig()`（启动顺序不变量失去锚点）—— " +
"若方法改名/搬走，请把锚点更新到新的真实调用点，" +
"**不要**删掉这条判据：它守的是「主密钥必须先于配置快照」")
}
// 安全模块的**生效点**是 InitConfigCodecWithOldKeys（配置加密子密钥派生）
secLine := lineOf("security.InitConfigCodecWithOldKeys(")
if secLine < 0 {
secLine = lineOf("security.InitConfigCodec(")
}
if secLine < 0 {
t.Fatal("找不到 InitConfigCodec 调用（安全模块装配点）")
}
// 密钥装载点也要在快照之前（两者都在安全块里）
keyLine := lineOf("security.LoadOrCreateKey(")
if secLine > snapLine {
t.Errorf("★ 安全模块装配（第 %d 行）在配置快照（第 %d 行）**之后** —— "+
"ToConfig() 会在无主密钥时读 core.llm.*.api_key，key 变空 ⇒ 全 provider 401。"+
"必须把整个安全块前移到 ToConfig() 之前", secLine, snapLine)
}
if keyLine < 0 {
t.Fatal("找不到 LoadOrCreateKey 调用")
}
if keyLine > snapLine {
t.Errorf("★ 主密钥装载（第 %d 行）在配置快照（第 %d 行）之后 —— 同上",
keyLine, snapLine)
}
// 且 provider 注册必须用**快照之后**的 cfg（这条锚定"快照确实被使用了"，
// 防止有人把 ToConfig() 挪到别处却没人发现）
// ★ 锚点已随"内核模块化"改写（2026-10-16）：provider 注册搬进 llm 模块，
// 由 `RunKernelModules` 触发 ⇒ 新的等价锚点是它。
// 不变量不变：provider 注册必须晚于配置快照（否则拿到空 key）。
asmLine := lineOf("RunKernelModules(")
if asmLine > 0 && asmLine < snapLine {
t.Errorf("★ 内核模块装配（第 %d 行）早于配置快照（第 %d 行）—— "+
"llm 模块会拿到空 key 注册 provider", asmLine, snapLine)
}
// ★ **第二个读取点**：SetLLMSnapshotFile 启动即快照 core.llm.*（会读密文）。
// 第一版判据只盯了 ToConfig() ⇒ 把它前移后判据变绿，但线上**照旧报**
// `listPrefix 解密 core.llm.api_key 失败: 无可用主密钥` ——
// 因为真正早于安全模块的是**这个**调用（main.go 里在 SeedDefaults 之后立刻执行）。
// 这正是本会话反复吃到的"判据只覆盖一个出口"：修一个点，另一个点照样漏。
snapFileLine := lineOf("cfgReg.SetLLMSnapshotFile(")
if snapFileLine < 0 {
t.Fatal("找不到 SetLLMSnapshotFile 调用")
}
if snapFileLine < secLine {
t.Errorf("★ SetLLMSnapshotFile（第 %d 行）早于安全模块装配（第 %d 行）—— "+
"启动即快照会读 core.llm.* 密文，主密钥还没装 ⇒ 密文解不开、快照写成空值，"+
"且日志刷 '无可用主密钥'。必须把安全块前移到它之前", snapFileLine, secLine)
}
}

42
cmd/homed/bootstrap_test.go
View File

@ -1,42 +0,0 @@
package main
import (
"os"
"path/filepath"
"testing"
)
// TestInitMemoryStackKeepsDistillerRunning 锁死启动接线回归：
// initMemoryStack 必须返回一个**仍在运行**的蒸馏器。
//
// 历史 bug：main() 拆分时函数体内残留一句 `defer distiller.Stop()`，
// 函数一 return 就 cancel 掉刚启动的循环，规则蒸馏 10min 心跳从不运行。
// 该缺陷不会让任何单测变红——pipeline 的 TestDistillOnce* 直接调
// distillOnce，绕过了 Start/Stop 接线；只有在这里按「启动阶段函数」的
// 真实调用方式断言，才照得出来。
func TestInitMemoryStackKeepsDistillerRunning(t *testing.T) {
dir := t.TempDir()
// NewGraphDB 需要父目录已存在（生产由 dataDir 初始化保证）。
if err := os.MkdirAll(filepath.Join(dir, "memory"), 0755); err != nil {
t.Fatal(err)
}
st, cleanup := initMemoryStack(dir, nil)
if st == nil || st.distiller == nil {
cleanup()
t.Fatal("initMemoryStack 未返回蒸馏器")
}
if st.db == nil {
cleanup()
t.Skip("图库未初始化，无法验证蒸馏接线")
}
if st.distiller.Stopped() {
cleanup()
t.Fatal("initMemoryStack 返回后蒸馏循环已被停掉（defer Stop 残留？）")
}
// cleanup 是唯一的停机点：先停蒸馏器、再关图库。
cleanup()
if !st.distiller.Stopped() {
t.Fatal("cleanup 之后蒸馏器应已停止")
}
}

4
cmd/homed/failback.go
View File

@ -22,7 +22,9 @@ import (
)
// runFailbackRecovery 在 failback worker 内执行 L1 恢复梯子：
// probe(rescue 源) → 还原 DNS/proxy → probe → 还原 LLM 配置快照+ReloadFromConfig → probe
//
// probe(rescue 源) → 还原 DNS/proxy → probe → 还原 LLM 配置快照+ReloadFromConfig → probe
//
// 成功后写 recovery_result.json 并以 exitRecovered 退出；失败以 exitRecoveryFailed 退出。
// 全程确定性、无 token 消耗（除 rescue 源 QuickChat 复检外）。
func runFailbackRecovery(dataDir string, cfgReg *internalConfig.ConfigRegistry, lua *luaVM.VM, providerMgr *agentAPI.ProviderManager, baseAPIKey string) {

47
cmd/homed/guard.go
View File

@ -532,40 +532,41 @@ func doLastResort(cfg *guardConfig) {
}
// ══════════════════════════════════════════════════════════════════════
// L2 自杀防护（2026-10-11）
//
// # 要防的是什么
// L2 自杀防护（2026-10-11）
//
// doLastResort(restart_app) 会执行 `systemctl restart <unit>`。而启用 guard 的
// 标准做法正是让 systemd 管理 `homed --role=guard` —— 也就是说 **<unit> 就是
// guard 自己所在的单元**。
// # 要防的是什么
//
// 于是 spawnWorker 失败时形成死循环：
// doLastResort(restart_app) 会执行 `systemctl restart <unit>`。而启用 guard 的
// 标准做法正是让 systemd 管理 `homed --role=guard` —— 也就是说 **<unit> 就是
// guard 自己所在的单元**。
//
// guard: doLastResort → systemctl restart homeagent
// → SIGTERM 杀掉自己 → systemd 按 Restart=always 拉起新 guard
// → 新 guard 再 spawn 失败 → 再自杀 ……
// 于是 spawnWorker 失败时形成死循环：
//
// 每轮都白跑一遍完整启动，且日志被刷爆。这与 2026-09-05 那次 systemd 审计
// 记录的事故同类（坏配置导致 836 次重启、79 分钟）。
// guard: doLastResort → systemctl restart homeagent
// → SIGTERM 杀掉自己 → systemd 按 Restart=always 拉起新 guard
// → 新 guard 再 spawn 失败 → 再自杀 ……
//
// # 正确解法不是「换个单元名」
// 每轮都白跑一遍完整启动，且日志被刷爆。这与 2026-09-05 那次 systemd 审计
// 记录的事故同类（坏配置导致 836 次重启、79 分钟）。
//
// 换成别的服务（重启 llmsproxy 之类）语义完全不对——L2 的本意是
// 「重启我自己」。而 systemd 的 Restart=already(always) 已经提供了这件事：
// # 正确解法不是「换个单元名」
//
// guard 自行退出 == systemd 重新拉起 == 重启整个单元
// 换成别的服务（重启 llmsproxy 之类）语义完全不对——L2 的本意是
// 「重启我自己」。而 systemd 的 Restart=already(always) 已经提供了这件事：
//
// 所以自指时应当**直接退出**，效果与 restart_app 完全等价，且没有自杀窗口。
// guard 自行退出 == systemd 重新拉起 == 重启整个单元
//
// # 为何还要保留 restart_command
// 所以自指时应当**直接退出**，效果与 restart_app 完全等价，且没有自杀窗口。
//
// 两种部署形态都合法：
// - systemd 管 guard（推荐）：自指 → 退出即可
// - 别的守护器管 guard（如 supervisor/前台 shell）：此时 guard 不是
// systemd 单元的 MainPID，restart_command 可能指向一个**正确**的其它单元，
// 或者根本不该执行
// 故不删除，只在「确实是自指」时改走退出路径，并留下明确日志。
// # 为何还要保留 restart_command
//
// 两种部署形态都合法：
// - systemd 管 guard（推荐）：自指 → 退出即可
// - 别的守护器管 guard（如 supervisor/前台 shell）：此时 guard 不是
// systemd 单元的 MainPID，restart_command 可能指向一个**正确**的其它单元，
// 或者根本不该执行
// 故不删除，只在「确实是自指」时改走退出路径，并留下明确日志。
func doLastResortGuarded(cfg *guardConfig, unit string) {
if unit != "" && isSelfRestartCommand(cfg.RestartCommand, unit) {
log.Printf("[guard] last_resort=restart_app 但 restart_command 指向自身单元 %q："+

18
cmd/homed/guard_config_test.go
View File

@ -245,16 +245,18 @@ func TestSnapshotBeforeDefaultsTrue(t *testing.T) {
// TestStartupGraceAllowsInit 钉住「启动宽限期」这一部署关键行为。
//
// ★ 场景（2026-10-12 生产部署实测触发的故障）：
// 停机 34s 后重启，heartbeat 文件 mtime 停在上一代 worker（已过期），
// 新 worker 要先做完全部重型初始化（chineseclip + 静态词向量 + 知识重建，
// 冷启动 5–8s）才开始写心跳。guard 的 5s ticker 先到、拿旧 mtime 判 stale
// → 把还在加载的 worker SIGKILL → 连续 6 次重启、guard 进入 failback
// Safe-Mode（服务降级）。
//
// 停机 34s 后重启，heartbeat 文件 mtime 停在上一代 worker（已过期），
// 新 worker 要先做完全部重型初始化（chineseclip + 静态词向量 + 知识重建，
// 冷启动 5–8s）才开始写心跳。guard 的 5s ticker 先到、拿旧 mtime 判 stale
// → 把还在加载的 worker SIGKILL → 连续 6 次重启、guard 进入 failback
// Safe-Mode（服务降级）。
//
// 不变量：
// (a) 宽限期内，即使心跳文件 mtime 极旧，也**不许**判杀
// (b) 宽限期满后，陈旧心跳**必须**判杀（卡死的 worker 不能靠宽限躲过去）
// (c) 宽限期满后，新鲜心跳不许判杀（误杀健康 worker 同样是事故）
//
// (a) 宽限期内，即使心跳文件 mtime 极旧，也**不许**判杀
// (b) 宽限期满后，陈旧心跳**必须**判杀（卡死的 worker 不能靠宽限躲过去）
// (c) 宽限期满后，新鲜心跳不许判杀（误杀健康 worker 同样是事故）
func TestStartupGraceAllowsInit(t *testing.T) {
dir := t.TempDir()
hb := filepath.Join(dir, "heartbeat")

188
cmd/homed/kmod_runtime.go Normal file
View File

@ -0,0 +1,188 @@
package main
// 内核模块装配的执行入口（Group 0 之后调用）。
import (
"fmt"
"log"
"os"
"path/filepath"
"strings"
"github.com/JianFeeeee/HomeAgent/internal/kernelboot"
"github.com/JianFeeeee/HomeAgent/internal/kernelmod"
// ★ 把全部内核模块**引入编译**（Go 要求 import 才会编译进来）。
// 加一个新模块 = 新建 internal/kernelmod/<name>/mod.go + 在 all.go 加一行。
_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/all"
)
// RunKernelModules 装配全部内核模块（必须在 Group 0 串行段之后调用）。
//
// ## 为什么"加模块零中央清单"在这里成立
//
// 各模块在自己的文件夹里写 `func init() { kernelmod.Register(...) }`，
// 由 `kernelmod/all` 统一引入编译。本函数只问注册表要模块，
// **不认识任何具体模块**，也不含任何依赖清单。
//
// ① 注册表（kernelmod）返回全部已注册模块（**乱序**，顺序无意义）
// ② Build：算依赖图层（缺依赖/环/重名 ⇒ 这里就报错）
// ③ Run：分层执行（同层有界并行），层边界更新 syncbus
//
// kernelAssembleHooks 是装配的**阶段回调**（供 main 在正确时机挂接）。
type kernelAssembleHooks struct {
// BeforeRun 在**执行任何模块之前**调用（此时 syncbus 已创建、
// 全部设施已 MarkDeclared，但还没有一个就绪）。
//
// ★★ 为什么需要它（一个真实的设计缺口）：
//
// 插件调度器若在装配**完成之后**才挂到 syncbus 上，那么它提交插件时
// 全部设施早已就绪 ⇒ 每个声明了依赖的插件都"立即拉起"
// ⇒ **「声明提前启动」从未真正生效**（永远退化成同步全就绪）。
//
// 实测证据（真机，2026-10-16）：装一个声明 requires_facilities=[config] 的
// 外部插件，它仍在内核**全部 5 层完成**后才被拉起 —— 因为 stage-host
// 就绪（第 3 层）时插件注册表才存在，而调度器那时还没接上拉起动作。
//
// 有了本回调，调度器在 **Run 之前**订阅 syncbus ⇒ 内核每完成一层
// 都会触发它重新评估 ⇒ 声明了 config 的插件不必等 agent 层。
BeforeRun func(bus *kernelboot.SyncBus) error
// OnLayerDone 在每层完成后调用（供 main 在 **stage-host 就绪** 的那一刻
// 接上插件拉起动作）。
//
// ★★ 为什么必须是"每层"而不是"全部完成后"：
//
// 插件加载需要 **plugin.Registry**，而它是 `stage-host` 模块的产物
// ⇒ 插件**不可能**早于 stage-host 被加载（这是硬约束）。
// 但 stage-host 在第 3 层，而 agent 在第 4 层 —— 而 agent 层实测要
// **35 秒**（context dense backfill 750 events + document/knowledge 重建索引）。
//
// ⇒ 声明了早期设施（config/llm）的插件完全没必要等那 35 秒。
// 在 stage-host 就绪那一刻接上拉起动作，它们就能立刻起。
//
// 实测收益（真机）：early_probe（只声明 config）从"装配全部完成后"
// 提前到"第 3 层完成时"，省掉 agent 层那 35 秒。
OnLayerDone func(idx int, layer []kernelboot.Module)
}
func RunKernelModules(ks *kernelboot.KernelState, hooks kernelAssembleHooks) (*kernelboot.SyncBus, error) {
mods, err := buildModuleList()
if err != nil {
return nil, err
}
// ★★ 启动顺序来自**编译期产出的图**（用户设计）。
//
// 编译期：homed-depgraph 算好分层 → depgraph.bin（含层号）+ digest 注入二进制
// 运行期：**读**这份图 ⇒ 不自己算顺序
//
// 这样"启动顺序"是**编译期制品**，可审计（进 PR diff）、可离线校验。
//
// 缺失/损坏/漂移策略：
// · dev（EmbeddedGraphHash 为空）：允许无图 ⇒ 回退运行期 Build（便于 go test/go run）
// · 生产（有 hash）：必须有图，且 hash 必须匹配，且层号必须与声明一致
// —— 任一不符 ⇒ **拒绝启动**（不猜哪边对：都是制品装配错误）
plan, err := loadStartupPlan(mods)
if err != nil {
return nil, err
}
bus := kernelboot.NewSyncBus()
// ★★ 先把**全部模块声明的设施**登记为"内核注册过"，**再**调用 BeforeRun。
//
// 时序很关键（我第一版搞反了，实测报了"内核已知的设施名: []"）：
//
// BeforeRun（attach）：插件调度器提交声明 ⇒ 触发**拼错校验**
// ⇒ 若此刻 known 为空，**所有声明都被误判为拼错**
// MarkDeclared ：把各模块的 Provides 登记进 known
//
// ⇒ 顺序必须是 **MarkDeclared → BeforeRun**。
// （Run 内部也会 MarkDeclared，那是为了"装配中途失败也成立"，
// 与本处不冲突 —— MarkDeclared 幂等。）
var allProvides []string
for _, layer := range plan.Layers {
for _, m := range layer {
allProvides = append(allProvides, m.Provides()...)
}
}
bus.MarkDeclared(allProvides)
// ★ 在**执行任何模块之前**挂接（插件调度器在这里订阅 syncbus）。
// 这样内核每完成一层都会触发调度器重新评估 ⇒ 声明提前启动**真的生效**。
if hooks.BeforeRun != nil {
if err := hooks.BeforeRun(bus); err != nil {
return nil, err
}
}
res, err := kernelboot.Run(plan, kernelboot.RunOptions{
State: ks,
Bus: bus,
// 并发上限：开 DB / 起 VM 很吃 IO，全放开会互相拖慢。
// 同层最多 8 个模块时 4 路并发实测最快（再高变 IO 争抢）。
MaxParallel: 4,
OnLayerDone: func(i int, layer []kernelboot.Module) {
names := make([]string, 0, len(layer))
for _, m := range layer {
names = append(names, m.Name())
}
log.Printf("[homed] 内核装配 第 %d 层完成（%d 个）: %s",
i, len(layer), strings.Join(names, ", "))
// ★ 把"某层完成"事件交给 main（用于在 stage-host 就绪时
// 立刻接上插件拉起动作，而不是等 agent 层的 35 秒）。
if hooks.OnLayerDone != nil {
hooks.OnLayerDone(i, layer)
}
},
})
if err != nil {
return nil, err
}
log.Printf("[homed] 内核装配完成: %d 层 / %d 模块（峰值并发 %d，原为 17 步串行）",
res.LayerCount, len(res.Order), res.MaxConcurrent)
return bus, nil
}
// loadStartupPlan 取启动计划：优先读**编译期图**，dev 环境回退运行期 Build。
func loadStartupPlan(mods []kernelboot.Module) (*kernelboot.Plan, error) {
exe, err := os.Executable()
if err != nil {
return nil, fmt.Errorf("无法确定二进制路径（图与它同目录）: %w", err)
}
graphPath := filepath.Join(filepath.Dir(exe), kernelboot.GraphFileName)
gf, err := kernelboot.LoadAndCheckGraph(graphPath, kernelboot.EmbeddedGraphHash)
if err != nil {
return nil, err
}
if gf == nil {
// dev：没有图（也没注入 hash）⇒ 运行期现算。
// 这条路径**不是**生产路径；它存在只为让 go test / go run 能用。
log.Printf("[homed] 未找到编译期依赖图（dev 构建），回退运行期分层")
return kernelboot.Build(mods)
}
plan, err := kernelboot.PlanFromGraph(gf, mods)
if err != nil {
return nil, err
}
log.Printf("[homed] 启动顺序来自编译期依赖图 %s（digest %s）",
filepath.Base(graphPath), gf.Digest[:16])
return plan, nil
}
// buildModuleList 从注册表取模块并做结构性检查。
func buildModuleList() ([]kernelboot.Module, error) {
if d := kernelmod.Duplicates(); len(d) > 0 {
return nil, fmt.Errorf("内核模块名重复注册: %v（两个模块取了同名，或同一模块被导入两次）", d)
}
mods := kernelmod.Registered()
if len(mods) == 0 {
return nil, fmt.Errorf("没有任何内核模块被登记 —— " +
"通常是没有 import internal/kernelmod/all（见 cmd/homed/kmod_runtime.go）")
}
return mods, nil
}

269
cmd/homed/main.go
View File

@ -4,18 +4,17 @@ import (
"context"
"log"
"path/filepath"
"strings"
internalConfig "github.com/JianFeeeee/HomeAgent/internal/config"
"github.com/JianFeeeee/HomeAgent/internal/memory"
"github.com/JianFeeeee/HomeAgent/internal/kernelboot"
"github.com/JianFeeeee/HomeAgent/internal/kernelmod/pluginhost"
"github.com/JianFeeeee/HomeAgent/internal/meta"
_ "github.com/JianFeeeee/HomeAgent/internal/plugins"
_ "github.com/JianFeeeee/HomeAgent/internal/plugins/clawhubadapter"
cli "github.com/JianFeeeee/HomeAgent/internal/plugins/cli"
_ "github.com/JianFeeeee/HomeAgent/internal/plugins/healthcheck"
_ "github.com/JianFeeeee/HomeAgent/internal/plugins/kbtree"
_ "github.com/JianFeeeee/HomeAgent/internal/plugins/pluginmgr"
webui "github.com/JianFeeeee/HomeAgent/internal/plugins/webui"
"github.com/JianFeeeee/HomeAgent/internal/security"
// 空白导入内置 provider：它们各自在 init 里注册到 pkg/embedding。
// 想把核心换成自己的模型，只需替换这一行（或另建一个发行版 main）。
@ -89,102 +88,187 @@ func main() {
defer cfgReg.Close()
cfgReg.SeedDefaults(opt.dataDir)
// LLM 配置写前留档（config_set 写 core.llm.* 前自动快照），guard 恢复用基线
cfgReg.SetLLMSnapshotFile(filepath.Join(opt.dataDir, "llm_snapshot.json"))
cfg := cfgReg.ToConfig()
// ---- 基础设施层：记忆、技能 ----
mem, closeMem := initMemoryStack(opt.dataDir, cfgReg)
defer closeMem()
// 共享词嵌入：蒸馏提取（Phase 3 TransE 验证）与 Agent 上下文复用同一实例，
// 避免同一模型被二次加载（约 200k×300 维 ≈ 数百 MB 内存）。
embedder := memory.NewStaticEmbedder(strings.Split(cfgReg.GetString("core.agent.embedding_model_path", ""), ",")...)
mem.distiller.SetEmbedder(embedder)
// ---- Lua VM（LLM 协议适配） ----
luaVM, closeLuaVM := initLuaVM(cfg)
defer closeLuaVM()
// ---- 守护管理（代理生命周期管理） ----
sup := initSupervisor(cfg)
// ---- 变更追踪（overlayfs） ----
trk := initTracker(cfg, agentWorkDir)
// ★ 锚点：本块必须在 SetLLMSnapshotFile / ToConfig 之前（两者都会读 core.llm.*）。
// ========================================================================
// 内核 API：IOManager（IO 抽象层） + EventBus（事件总线）
// 所有插件通过这两个通道与核心交互
// ★ 安全模块必须在**任何读 core.llm.* 的操作之前**装配。
//
// 实测故障（2026-10-16，自己引入的）：安全块原先放在 ToConfig() 之后。
// 于是 ToConfig() 在**没有主密钥**的情况下读 core.llm.*.api_key ——
// 密文解不开，key 变成空串，而 initLLMProviders(cfg,...) 用的正是这份
// 早期快照 ⇒ 所有 LLM 调用 401 invalid api key。
//
// 症状极具误导性：日志里只有一行 `Dump 解密 ... 失败: security: 无可用主密钥`，
// 而 401 看起来像“key 配错了”。实际是**启动顺序**问题。
//
// 约束：安全块只依赖 cfgReg（不依赖 cfg），所以可以安全前移。
// ========================================================================
if cfgReg.GetBool("core.security.enabled", true) {
// ★ 先收敛数据目录与敏感文件权限（幂等），再读密钥。
//
// 顺序有意为之：内嵌主密钥把密钥放进了 0755 的二进制里，
// 而 config.db 出厂是 0644 —— 「能读二进制就能解密数据库」。
// 收紧到 0600/0750 是本机缓解手段，必须在服务开始读写之前生效。
//
// 失败不 Fatal（权限问题不该让服务不可用），但会逐条响亮记录。
if hr := security.HardenDataDir(opt.dataDir); len(hr.Changed) > 0 {
log.Printf("[homed] 已收紧 %d 项权限（内嵌密钥场景的必要缓解）: %v",
len(hr.Changed), hr.Changed)
}
key, keySrc, kerr := security.LoadOrCreateKey(opt.dataDir)
if kerr != nil {
log.Fatalf("[homed] 安全模块密钥初始化失败（拒绝以降级模式启动）: %v", kerr)
}
// E-1：若存在密钥环，装入历史钥（只读旧密文；当前钥仍由
// systemd credential/env/security.key 提供）。密钥环损坏或 current 不一致
// 必须响亮失败，不能猜一把钥继续启动。
oldKeys, rerr := security.LoadKeyring(opt.dataDir, key)
if rerr != nil {
log.Fatalf("[homed] 安全模块密钥环加载失败（拒绝静默选错钥）: %v", rerr)
}
// ★ 内嵌钥上台时，磁盘钥必须继续参与**解密**。
//
// 否则一台用磁盘钥加密过的老机器升级到内嵌了另一把钥的二进制后，
// 旧密文会全部解不开 ⇒ 服务起不来；用户此时若选择"重建库"，
// 凭据就**一次性全丢** —— 那恰好与内嵌的初衷（防丢）相反。
//
// 与 E-1 同一套语义：当前钥负责 Seal，旧钥只参与 Open。
if extra := security.AdditionalDecryptKeys(opt.dataDir, key); len(extra) > 0 {
oldKeys = append(oldKeys, extra...)
}
if len(oldKeys) > 0 {
log.Printf("[homed] 安全模块已装入 %d 把历史/额外密钥（E-1 平滑轮换 + 内嵌迁移）", len(oldKeys))
}
if _, serr := security.InitGlobal(security.Options{
Path: filepath.Join(opt.dataDir, "security", "variables.json"),
KeyFn: func() ([]byte, error) { return key, nil },
OldKeys: oldKeys,
Enabled: true,
}); serr != nil {
log.Fatalf("[homed] 安全模块变量库加载失败（不静默重建）: %v", serr)
}
// 配置落盘用的子密钥（域隔离：与别名密钥不共用）。
// 必须早于 EncryptExistingSecrets，后者依赖它。
if _, cerr := security.InitConfigCodecWithOldKeys(key, oldKeys); cerr != nil {
log.Fatalf("[homed] 配置加密子密钥派生失败: %v", cerr)
}
// 把库里仍是明文的敏感项就地加密（幂等；升级路径必须跑）。
if n, merr := cfgReg.EncryptExistingSecrets(); merr != nil {
// 不 Fatal：库可能是只读/被锁，而“部分为明文”不等于服务不可用。
// 但要**响亮告警**：这是用户必须知道的安全事实。
log.Printf("[homed] 存量敏感配置加密未完成（部分项仍为明文）: %v", merr)
} else if n > 0 {
log.Printf("[homed] 已加密 %d 条存量敏感配置", n)
}
log.Printf("[homed] 安全模块已启用（密钥来源 %s，变量 %d 条，配置落盘加密已开启）",
keySrc, security.Global().Count())
iom, evBus := initKernelAPI()
// ---- 文本记忆 + 记忆蒸馏管线 ----
textMem, closeTextMem := initTextMemory(cfg)
defer closeTextMem()
ctx, stop := context.WithCancel(context.Background())
defer stop()
startMemoryCandidateConsumer(ctx, iom, textMem, mem.db, mem.distiller)
// ---- LLM Provider 管理（多源，通过 Lua 适配器协议转换） ----
baseAPIKey := resolveBaseAPIKey(cfg)
providerMgr := initLLMProviders(cfg, luaVM, baseAPIKey)
provider := providerMgr.Default()
// L1 failback：受限 worker 启动即跑恢复梯子（probe→还原DNS/proxy→还原config+ReloadFromConfig→probe），
// 结果以退出码 exitRecovered=43 / exitRecoveryFailed=44 交回 guard，不进入主 agent 循环。
if opt.boot == "failback" {
runFailbackRecovery(opt.dataDir, cfgReg, luaVM, providerMgr, baseAPIKey)
// ★ E-2：备份跨机器恢复的诊断。
//
// 场景：把 config.db 备份恢复到另一台机器，而主密钥没一起搬过来
// ⇒ 库里密文是**旧机器密钥**加的，当前钥解不开。
// 此前这种状态只在“读某一条配置”时才暴露成“某个功能坏了”，
// 用户看到的是症状而不是原因。这里一次性说清事实与修复动作。
if okN, badN, aerr := cfgReg.AuditSecrets(); aerr == nil && badN > 0 {
log.Printf("[homed] ⚠ 检测到 %d 条密文无法用当前主密钥解开（可解 %d 条）—— "+
"最常见原因是：这份 config.db 来自**另一台机器/另一个密钥**。"+
"修复：把原机器的密钥一起带过来（systemd credential / %s / "+
"%s），或用旧密钥启动一次并执行重加密迁移。",
badN, okN, security.EnvKeyName, security.KeyringFileName)
}
} else {
log.Printf("[homed] 安全模块被显式关闭（core.security.enabled=false）—— 明文落盘且中转无防护")
}
// ---- 文档记忆 + 知识库 ----
// ========================================================================
// ★ 内核装配：公共结构体 + 模块注册表（用户设计）
//
// Group 0（上面到这里的部分：平台门/心跳/日志/配置库/安全块）是
// **副作用顺序**要求，不进调度器 —— 依赖图表达不了"此动作必须在
// 那个动作之前生效"（图表达的是"我产出数据给他"）。见 kmod_group0 说明
// 与 bootstrap_order_test.go 的结构性判据。
//
// 从 cfg 起全部改为**模块自声明依赖 + 注册表 + BFS 分层**：
// · 公共数据统一在 kernelboot.KernelState（不再散落各包包级变量）
// · 每个模块在 internal/kernelmod/<name>/ 里**自己声明** Requires/Provides
// · 注册表是乱序的（顺序无意义，仅供查询"内核有哪些模块"）
ks := kernelboot.NewKernelState()
ks.CfgReg = cfgReg
ks.DataDir = opt.dataDir
ks.AgentWorkDir = agentWorkDir
ks.CLISocket = opt.cliSocket
ks.HTTPAddr = opt.httpAddr
ks.Ctx, ks.Stop = context.WithCancel(context.Background())
docStore, closeDocStore := initDocStore(cfg)
defer closeDocStore()
// ★ Group 0 的最后两步（读 core.llm.*，必须在安全块之后）：
// 它们归 config 模块的产物路径，但**执行点**在这里 —— 阶段依赖。
cfgReg.SetLLMSnapshotFile(filepath.Join(opt.dataDir, "llm_snapshot.json"))
ks.Cfg = cfgReg.ToConfig()
multimodalSpace, mmProviderName, mmErr, closeMultimodal := initMultimodalSpace(cfgReg)
defer closeMultimodal()
// 装配全部内核模块（缺依赖/环/重名 ⇒ 这里就报错，不必等运行期）。
//
// ★ 插件调度已**归位到内核模块**（`internal/kernelmod/pluginhost`，
// 用户方案 A）：它负责扫元数据缓存、按三形态分流、按依赖时机拉起。
// main 这里不再有插件调度逻辑 —— 只保留装配后的一点点收尾。
// ★★ failback 的插件**白名单必须在装配之前**设置。
//
// 原因：插件拉起已归位到 plugin-host 模块，而它在**装配期**执行
// ⇒ 白名单若在装配后才设，插件早已按全量拉起了（受限启动就失效了）。
//
// 这是把调度搬进模块后引入的**新时序要求** —— 原先调度在装配后，
// 所以把 allowlist 放在装配后也无害。迁移时必须重新核对这类顺序。
//
// 注意：白名单要的是 plugin.Registry，而它是 stage-host 的产物
// ⇒ 装配前拿不到。所以这里传 nil 的 registry 只算白名单名（logged），
// 真正的 SetLoadAllowlist 由装配期的钩子在 registry 就绪后执行。
pendingAllowlist := resolveFailbackAllowlist(cfgReg, opt.boot, opt.dataDir)
// 迁移必须在 store 扫盘**之前**：改名后扫盘一次到位，
// 避免先以旧名建索引、再改名造成内存键与盘上目录短暂不一致。
initKnowledgeMigration(cfg)
ks := initKnowledgeStore(cfg)
// 装配全部内核模块（缺依赖/环/重名 ⇒ 这里就报错，不必等运行期）。
//
// ★ 插件调度已**归位到内核模块**（`internal/kernelmod/pluginhost`，
// 用户方案 A）：它负责扫元数据缓存、按三形态分流、按依赖时机拉起。
// main 这里不再有插件调度逻辑 —— 只保留装配后的一点点收尾。
if _, err := RunKernelModules(ks, kernelAssembleHooks{
// 在 stage-host 就绪、插件真正拉起**之前**把白名单设上。
OnLayerDone: func(_ int, _ []kernelboot.Module) {
if pendingAllowlist != nil && ks.PluginRegistry != nil {
ks.PluginRegistry.SetLoadAllowlist(pendingAllowlist)
}
},
}); err != nil {
log.Fatalf("[homed] 内核装配失败: %v", err)
}
defer ks.CloseAll()
// ---- 人格设定 ----
cfg := ks.Cfg
luaVM := ks.LuaVM
sup := ks.Supervisor
trk := ks.Tracker
ctx := ks.Ctx
pluginReg := ks.PluginRegistry
agent := ks.Agent
personality := loadPersonality(cfg, cfgReg)
// 候选消费管线：常驻 goroutine，把 eventbus 的 memory_candidate 写进
// 文本记忆并喂给蒸馏管线。原顺序里它在 textmem 之后、provider 之前。
startMemoryCandidateConsumer(ctx, ks.IO, ks.TextMemory, ks.Memory.DB, ks.Memory.Distiller)
// ---- 阶段管道（StageHost）+ 插件系统（Registry） ----
// L1 failback：受限 worker 启动即跑恢复梯子，结果以退出码交回 guard。
if opt.boot == "failback" {
runFailbackRecovery(opt.dataDir, cfgReg, luaVM, ks.LLMManager, ks.BaseAPIKey)
}
stageHost, pluginReg := newStageAndRegistry(cfg, cfgReg, iom, evBus, mem.db, textMem,
docStore, ks, providerMgr, opt.dataDir)
// ---- Agent Core (需在插件加载前创建，因为插件 Configure 需要 StatusProvider) ----
agent := newMainAgent(cfg, cfgReg, provider, providerMgr, iom, mem.db, mem.indexer, trk,
docStore, ks, mem.social, textMem, personality, pluginReg, embedder,
multimodalSpace, mmProviderName, mmErr, stageHost, evBus)
wirePluginSDK(pluginReg, luaVM, baseAPIKey, sup, trk, cfg, stageHost, mem.indexer, agent)
// 为内置插件注入内核依赖（各插件通过 init() 自注册工厂）
cli.DefaultSocket = opt.cliSocket
// webui 监听地址覆盖：必须在 loadPlugins 之前设置，插件 Start 时会读它。
webui.SetListenOverride(resolveWebUIOverride(cfgReg, opt.httpAddr))
// ---- 依存句法分析器（内嵌 ONNX 模型 / 规则引擎） ----
initONNXParser(cfg, cfgReg)
loadPlugins(cfg, cfgReg, pluginReg, stageHost, opt.boot, opt.dataDir)
// ---- 插件已完成调度（plugin-host 模块做的事）----
//
// 装配期 plugin-host 已：
// ① 扫目录建元数据缓存（ks.PluginCatalog）
// ② 按三形态分流（自动启动 / 不自动启动 / 禁用）
// ③ 拉起"声明设施已就绪"的插件；挂起"等更晚设施（如 agent）"的
// （挂起项经 syncbus 在 agent 就绪时自动拉起，见 pluginhost/waiter.go）
if cat, ok := ks.PluginCatalog.(*pluginhost.PluginCatalog); ok {
log.Printf("[homed] 插件调度完成：元数据缓存 %d 个，已加载 %d 个",
cat.Size(), len(pluginReg.ListLoadedPlugins()))
} else {
log.Printf("[homed] 插件调度完成：已加载 %d 个", len(pluginReg.ListLoadedPlugins()))
}
// 插件加载完成后再回收空闲页：大值（如老版聊天记录）可能在这一步被搬走/删除，
// 而 SQLite 的 DELETE 不会缩小文件。
@ -205,5 +289,12 @@ func main() {
// ---- 等待退出信号 ----
//
// 心跳已在 main 早期启动（见文件头部 startHeartbeatEarly），此处不再重复启动。
waitForShutdown(ctx, opt.dataDir, restartCh, stopHeartbeatEarly, pluginReg, trk, cfgReg, sup)
// stopKernelModules：热更新路径（os.Exit 跳过 defer）下也要跑模块关闭。
// CloseAll 幂等（第二次 Closers 已空）⇒ 与 defer 并存是安全的。
waitForShutdown(ctx, opt.dataDir, restartCh, stopHeartbeatEarly, pluginReg, trk, cfgReg, sup,
func() {
if err := ks.CloseAll(); err != nil {
log.Printf("[homed] 模块关闭: %v", err)
}
})
}

79
cmd/homed/memcandidate.go Normal file
View File

@ -0,0 +1,79 @@
package main
// 记忆候选消费管线（常驻 goroutine）。
//
// ## 为什么放在 cmd/homed 而不是某个模块包里
//
// 它**不产出任何产物**（纯副作用：把事件写进文本记忆与蒸馏管线）⇒
// 没有"注册到 KernelState"的价值，也不是一个可被依赖的设施。
//
// 但它**依赖** memory（distiller/memDB）与 kernel-io（iom）的产物，
// 所以必须在内核装配**完成之后**启动 —— 由 main.go 在
// RunKernelModules 之后调用（原顺序里它在 textmem 之后、provider 之前）。
import (
"context"
"log"
"time"
agentIO "github.com/JianFeeeee/HomeAgent/internal/agent/io"
"github.com/JianFeeeee/HomeAgent/internal/memory"
"github.com/JianFeeeee/HomeAgent/internal/memory/pipeline"
"github.com/JianFeeeee/HomeAgent/internal/memory/text"
)
// startMemoryCandidateConsumer 起一个常驻 goroutine：把 eventbus 上的
// memory_candidate 事件写进文本记忆并喂给蒸馏管线。
func startMemoryCandidateConsumer(ctx context.Context, iom *agentIO.IOManager,
textMem *text.Memory, memDB *memory.GraphDB, distiller *pipeline.Distiller) {
go func() {
for {
select {
case <-ctx.Done():
return
case evt, ok := <-iom.OutputChan():
if !ok {
return
}
if evt.Target == "memory" && evt.Type == "memory_candidate" {
source, _ := evt.Payload["source"].(string)
input, _ := evt.Payload["input"].(string)
response, _ := evt.Payload["response"].(string)
toolsUsed, _ := evt.Payload["tools_used"].([]string)
toolResults, _ := evt.Payload["tool_results"].([]interface{})
agentID, _ := evt.Payload["agent_id"].(string)
if input != "" && textMem != nil {
te := text.Event{
Timestamp: time.Now().Unix(),
Source: source,
Input: input,
Response: response,
ToolsUsed: toolsUsed,
AgentID: agentID,
}
if err := textMem.Append(te); err != nil {
log.Printf("[homed] text memory append: %v", err)
}
}
if input != "" && memDB != nil {
distiller.Append("agent", "user", input)
}
if response != "" && memDB != nil {
distiller.Append("agent", "assistant", response)
}
// 工具输出接入蒸馏管线
for _, tr := range toolResults {
if trMap, ok := tr.(map[string]interface{}); ok {
if out, ok := trMap["output"].(string); ok && out != "" && memDB != nil {
distiller.Append("agent", "tool", out)
}
}
}
}
}
}
}()
}

80
cmd/homed/plugins_scheduled.go Normal file
View File

@ -0,0 +1,80 @@
package main
// 按 syncbus 状态**分阶段**拉起插件（设计 §2.6）。
//
// ## 三条规则（按优先级）
//
// 未声明 requires_facilities ⇒ 等内核**完全**初始化 ← **现行为，零改动**
// 声明了且依赖全就绪 ⇒ 立即拉起（**尽早启动**）
// 声明了但依赖未齐 ⇒ 挂起，等 syncbus 更新
// 声明 auto_start=false ⇒ 不自动拉起，等 agent 显式启用
//
// ## ★ 兼容性硬约束（§2.6.5）
//
// 存量 42 个插件都不声明依赖 ⇒ 全部走第一条 ⇒ 启动时机**逐字不变**。
// 这不是"顺便兼容"，而是硬约束：任何一个存量插件若因本设计改变启动时机，
// 就可能在不该动的时候动（如假设"我 Start 时 llm 已就绪"）。
// **静默改变启动时机 = 静默引入竞态。**
import (
"log"
"strings"
internalConfig "github.com/JianFeeeee/HomeAgent/internal/config"
"github.com/JianFeeeee/HomeAgent/internal/plugin"
"github.com/JianFeeeee/HomeAgent/internal/recovery"
)
// resolveFailbackAllowlist 解析 failback 受限启动的插件白名单（装配**前**调用）。
//
// 返回 nil 表示非 failback 模式（普通启动不设白名单）。
func resolveFailbackAllowlist(cfgReg *internalConfig.ConfigRegistry,
bootMode, dataDir string) []string {
if bootMode != "failback" {
return nil
}
list := cfgReg.GetString("core.agent.failback_plugins", "webui,pluginmgr,recoverydiag")
// 优先使用 guard.yaml 经 recovery 任务下发的插件集（guard 是 failback 权威）
if task, terr := recovery.LoadTask(recovery.TaskPath(dataDir)); terr == nil && len(task.Plugins()) > 0 {
list = strings.Join(task.Plugins(), ",")
}
var names []string
for _, s := range strings.Split(list, ",") {
if s = strings.TrimSpace(s); s != "" {
names = append(names, s)
}
}
log.Printf("[homed] failback boot: plugin allowlist = %v（装配前解析）", names)
return names
}
// applyFailbackPluginAllowlist 在 **failback 受限启动**下设置插件白名单。
//
// ## ★ 必须在插件被拉起**之前**生效
//
// failback 是内核的受限恢复模式：只加载少量插件（webui/pluginmgr/recoverydiag）
// 以便直接产出恢复结论。白名单由 `guard.yaml` 的 recovery 任务或配置决定。
//
// 现在插件拉起由 plugin-host 模块负责，而它在装配期跑 ⇒ 本函数必须在
// **装配之前**被调用（main 里已如此安排）。
//
// 非 failback 模式：本函数什么都不做（普通启动不设白名单）。
func applyFailbackPluginAllowlist(cfgReg *internalConfig.ConfigRegistry,
pluginReg *plugin.Registry, bootMode, dataDir string) {
if bootMode != "failback" || pluginReg == nil {
return
}
list := cfgReg.GetString("core.agent.failback_plugins", "webui,pluginmgr,recoverydiag")
// 优先使用 guard.yaml 经 recovery 任务下发的插件集（guard 是 failback 权威）
if task, terr := recovery.LoadTask(recovery.TaskPath(dataDir)); terr == nil && len(task.Plugins()) > 0 {
list = strings.Join(task.Plugins(), ",")
}
var names []string
for _, s := range strings.Split(list, ",") {
if s = strings.TrimSpace(s); s != "" {
names = append(names, s)
}
}
pluginReg.SetLoadAllowlist(names)
log.Printf("[homed] failback boot: plugin allowlist = %v", names)
}

125
cmd/homed/shutdown_flush_test.go Normal file
View File

@ -0,0 +1,125 @@
package main
// 停机**两条路径对称性**的判据（2026-10-17）。
//
// ## 缺陷（实测发现）
//
// `main()` 里有 `defer ks.CloseAll()`，但 `waitForShutdown` 在重启路径上
// 调用 `os.Exit(exitRestartRequested)` —— **os.Exit 不跑 defer**。
// ⇒ 两条退出路径的资源清理**不对称**：
//
// 路径 A（SIGTERM）: return 到 main → defer CloseAll ✓
// 路径 B（exit 42）: os.Exit 跳过 defer ✗
//
// 而路径 B 是**每次热更新都走**的（guard 靠 exit 42 判定"主动重启"）。
// 后果是这些写者从不 flush：
// · docStore.Stop() → flush() 文档索引可能陈旧
// · distiller.Stop() → flush() 待蒸馏规则丢失
// · textMem.Stop() → Close() 文本记忆未落盘
//
// ## 判据怎么咬
//
// 不能靠"源码里有 os.Exit 吗"（写意不写实）。这里用 **AST** 检查
// `waitForShutdown` 函数体里**在 os.Exit 之前**确实调用了传入的
// stopKernelModules 形参 —— 即"退出前显式关闭"，而不是靠 defer。
import (
"go/ast"
"go/parser"
"go/token"
"testing"
)
// ★★★ 判据：waitForShutdown 在 os.Exit 之前显式调用 stopKernelModules。
func TestWaitForShutdownClosesModulesBeforeExit(t *testing.T) {
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "bootstrap.go", nil, 0)
if err != nil {
t.Fatal(err)
}
var fn *ast.FuncDecl
for _, d := range f.Decls {
if fd, ok := d.(*ast.FuncDecl); ok && fd.Name.Name == "waitForShutdown" {
fn = fd
}
}
if fn == nil {
t.Fatal("找不到 waitForShutdown")
}
// 找 os.Exit 与 stopKernelModules() 调用的相对位置（按字节偏移）
exitPos := token.NoPos
closePos := token.NoPos
ast.Inspect(fn, func(n ast.Node) bool {
call, ok := n.(*ast.CallExpr)
if !ok {
return true
}
if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
if id, ok := sel.X.(*ast.Ident); ok && id.Name == "os" && sel.Sel.Name == "Exit" {
if !exitPos.IsValid() {
exitPos = call.Pos()
}
}
}
if id, ok := call.Fun.(*ast.Ident); ok && id.Name == "stopKernelModules" {
if !closePos.IsValid() {
closePos = call.Pos()
}
}
return true
})
if !exitPos.IsValid() {
t.Fatal("waitForShutdown 里没有 os.Exit（重启路径怎么退出的？）")
}
if !closePos.IsValid() {
t.Fatal("★ waitForShutdown 从未调用 stopKernelModules ⇒ " +
"热更新路径（os.Exit 跳过 defer）下模块关闭/落盘全部被跳过")
}
if closePos > exitPos {
t.Fatal("★ stopKernelModules 在 os.Exit **之后** ⇒ 永远不会执行" +
"（os.Exit 立即终止进程）")
}
}
// ★★★ 判据：main 必须把真实的 ks.CloseAll 传给 waitForShutdown（不是空函数）。
func TestMainWiresRealCloseAllIntoShutdown(t *testing.T) {
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "main.go", nil, 0)
if err != nil {
t.Fatal(err)
}
found := false
ast.Inspect(f, func(n ast.Node) bool {
call, ok := n.(*ast.CallExpr)
if !ok {
return true
}
id, ok := call.Fun.(*ast.Ident)
if !ok || id.Name != "waitForShutdown" {
return true
}
// 最后一个实参必须是含有 CloseAll 调用的函数字面量
for _, a := range call.Args {
lit, ok := a.(*ast.FuncLit)
if !ok {
continue
}
ast.Inspect(lit, func(m ast.Node) bool {
if c, ok := m.(*ast.CallExpr); ok {
if sel, ok := c.Fun.(*ast.SelectorExpr); ok && sel.Sel.Name == "CloseAll" {
found = true
}
}
return true
})
}
return true
})
if !found {
t.Fatal("★ main 传给 waitForShutdown 的 stopKernelModules 里没有 CloseAll ⇒ " +
"热更新路径下模块不会被关闭（传了个空函数？）")
}
}

113
cmd/homed/shutdown_idempotent_test.go Normal file
View File

@ -0,0 +1,113 @@
package main
// 退出路径的**幂等性**判据（2026-10-17）。
//
// ## 为什么必须有这条
//
// 实测 panic（真机 SIGTERM）：
//
// panic: close of closed channel
// goroutine 1 [running]:
// main.startHeartbeat.func3() bootstrap.go:259
// main.main() main.go:293
//
// 根因：`startHeartbeat` 返回的 stop 函数是裸的 `close(hbStop)`，
// 而它有**两个**调用点：
// - main.go 的 `defer stopHeartbeatEarly()`
// - waitForShutdown 里显式 `stopHeartbeat()`
//
// ⇒ 第二次 close 必然 panic。
//
// ## 为什么这条缺陷很值得守
//
// 它发生在**退出路径的最后一步**：进程已经把所有清理做完了，
// 却在收尾时崩溃 ⇒ 退出码从 0 变成 2（panic）⇒
// systemd/guard 把它判成"异常退出"而不是"正常停止"，
// 进而触发**不必要的重启/告警**。而功能上一切正常，
// 排查方向会被引向"是不是哪里崩了"。
//
// ## 判据形态
//
// 断言「close(停止通道) 必须被 sync.Once（或等价）保护」。
// 这是"模式存在性"，源码扫描恰当；行为验证由真机 SIGTERM 做
// （已实测：修前 panic、修后 `[homed] stopped` 且 0 panic）。
import (
"os"
"strings"
"testing"
)
// ★★★ 判据：startHeartbeat 的 stop 函数必须幂等。
func TestStartHeartbeatStopIsIdempotent(t *testing.T) {
src, err := os.ReadFile("bootstrap.go")
if err != nil {
t.Fatal(err)
}
code := string(src)
// 找 startHeartbeat 函数体
i := strings.Index(code, "func startHeartbeat(")
if i < 0 {
t.Skip("startHeartbeat 已改名/搬走，请同步更新判据")
}
end := strings.Index(code[i:], "\n}\n")
if end < 0 {
t.Fatal("找不到 startHeartbeat 结尾")
}
body := code[i : i+end]
// 必须返回 stop 函数
if !strings.Contains(body, "return func()") {
t.Skip("stop 函数的形态已变，请同步更新判据")
}
// ★ 核心：裸 close 是缺陷
if strings.Contains(body, "return func() { close(") {
t.Fatal("★ startHeartbeat 的 stop 函数是**裸的 close()** —— " +
"而它有两个调用点（main 的 defer + waitForShutdown 的显式调用）\n" +
" ⇒ 第二次 close 必然 panic: close of closed channel\n" +
" ⇒ 退出码从 0 变 2 ⇒ systemd/guard 判成异常退出并重启。\n" +
" 修法：用 sync.Once 保护。")
}
// 正向：必须有 sync.Once（或至少 Once.Do）
if !strings.Contains(body, "sync.Once") && !strings.Contains(body, ".Do(") {
t.Error("★ startHeartbeat 的 stop 函数没有幂等保护（sync.Once）")
}
}
// ★★★ 判据：**所有**返回 stop 函数的启动函数都必须幂等。
//
// 一般化：本仓的 stop 函数习惯上既被 defer 调、又被显式调，
// 裸 close 是通用的坑。
func TestNoBareChannelCloseInStopFunctions(t *testing.T) {
entries, err := os.ReadDir(".")
if err != nil {
t.Fatal(err)
}
bad := 0
for _, e := range entries {
if e.IsDir() || !strings.HasSuffix(e.Name(), ".go") ||
strings.HasSuffix(e.Name(), "_test.go") {
continue
}
b, err := os.ReadFile(e.Name())
if err != nil {
continue
}
lines := strings.Split(string(b), "\n")
for idx, ln := range lines {
trim := strings.TrimSpace(ln)
// 只查"返回 stop 函数且其中裸 close"的形态
if !strings.Contains(trim, "return func()") {
continue
}
// 同一行内联形态：return func() { close(x) }
if strings.Contains(trim, "close(") && !strings.Contains(trim, "Do(") {
t.Errorf("★ %s:%d 返回的 stop 函数是裸 close（调用两次即 panic）: %s",
e.Name(), idx+1, trim)
bad++
}
}
}
_ = bad
}

24
cmd/mock-server/main.go
View File

@ -26,11 +26,11 @@ type Kernel struct {
}
type Setting struct {
Settings map[string]interface{} `json:"settings"`
Meta map[string]interface{} `json:"meta"`
Plugins []string `json:"plugins"`
PluginMeta map[string]interface{} `json:"plugin_meta"`
DisabledPlugins []string `json:"disabled_plugins"`
Settings map[string]interface{} `json:"settings"`
Meta map[string]interface{} `json:"meta"`
Plugins []string `json:"plugins"`
PluginMeta map[string]interface{} `json:"plugin_meta"`
DisabledPlugins []string `json:"disabled_plugins"`
}
type Plugin struct {
@ -42,12 +42,12 @@ type Plugin struct {
}
type PluginInfo struct {
Name string `json:"name"`
Description string `json:"description"`
Version string `json:"version"`
Enabled bool `json:"enabled"`
Builtin bool `json:"builtin"`
Tools []PluginTool `json:"tools"`
Name string `json:"name"`
Description string `json:"description"`
Version string `json:"version"`
Enabled bool `json:"enabled"`
Builtin bool `json:"builtin"`
Tools []PluginTool `json:"tools"`
}
type PluginTool struct {
@ -518,4 +518,4 @@ func main() {
log.Printf("设备桥 WS: ws://0.0.0.0%s/api/v1/device/ws", addr)
log.Printf("==============================")
log.Fatal(http.ListenAndServe(addr, server.middleware(mux)))
}
}

2
cmd/mock-server/ws.go
View File

@ -469,4 +469,4 @@ func (s *MockServer) handleDeviceWS(w http.ResponseWriter, r *http.Request) {
s.mu.Unlock()
}
log.Printf("[ws] 设备断开")
}
}

4
cmd/waiter/daemon.go
View File

@ -15,6 +15,7 @@ import (
"time"
"github.com/JianFeeeee/HomeAgent/internal/devicebridge/client"
safeclose "github.com/JianFeeeee/HomeAgent/internal/safeclose"
)
// ---------------------------------------------------------------------------
@ -38,6 +39,7 @@ type msgEntry struct {
}
type daemonHandler struct {
stopOnce sync.Once
// homed 连接
homeMu sync.Mutex
homeConn net.Conn
@ -255,7 +257,7 @@ func runDaemon(cfg *Config) {
go func() {
<-sigCh
log.Printf("[daemon] shutting down")
close(dh.stopCh)
safeclose.Safe(&dh.stopOnce, dh.stopCh)
dh.closeHome()
ln.Close()
}()

4
cmd/waiter/main.go
View File

@ -13,6 +13,7 @@ import (
"time"
"github.com/JianFeeeee/HomeAgent/internal/meta"
safeclose "github.com/JianFeeeee/HomeAgent/internal/safeclose"
)
const (
@ -47,6 +48,7 @@ func startSpinner(label string) func() {
}
done := make(chan struct{})
var once sync.Once
var doneOnce sync.Once
go func() {
ticker := time.NewTicker(80 * time.Millisecond)
defer ticker.Stop()
@ -63,7 +65,7 @@ func startSpinner(label string) func() {
}()
stop := func() {
once.Do(func() {
close(done)
safeclose.Safe(&doneOnce, done)
fmt.Print(clearLine)
})
}

10
cmd/waiter/raw_windows.go
View File

@ -9,14 +9,14 @@ import (
)
var (
kernel32 = syscall.NewLazyDLL("kernel32.dll")
procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
procSetConsoleMode = kernel32.NewProc("SetConsoleMode")
procGetStdHandle = kernel32.NewProc("GetStdHandle")
kernel32 = syscall.NewLazyDLL("kernel32.dll")
procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
procSetConsoleMode = kernel32.NewProc("SetConsoleMode")
procGetStdHandle = kernel32.NewProc("GetStdHandle")
)
const (
stdInputHandle = ^uint32(9) + 1 // -10
stdInputHandle = ^uint32(9) + 1 // -10
enableVirtualTerminalProcessing = 0x0004
enableProcessedOutput = 0x0001
enableWrapAtEOLOutput = 0x0002

4
cmd/waiter/state.go
View File

@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
safeclose "github.com/JianFeeeee/HomeAgent/internal/safeclose"
"sync"
)
@ -171,11 +172,12 @@ func (s *State) ReadLoop(ctx context.Context, cb func(string)) {
return
}
done := make(chan struct{})
var doneOnce sync.Once
var line string
var readErr error
go func() {
line, readErr = c.ReadLine()
close(done)
safeclose.Safe(&doneOnce, done)
}()
select {
case <-done: