feat(jarvis): 能动的手(写文件/执行命令,三道闸) + 定时任务调度

此前 JARVIS 只能看不能动(本地工具纯只读)、也不会调度,补齐这两块。【能动的手】local_write_file / local_exec,在用户自选工作目录内动手: - 独立开关:只开只读访问不给这能力,须单独勾「允许写文件/执行命令」 - 原生确认框逐次审批:展示命令原文,默认按钮=拒绝,60s 无人应答按拒绝 (防无人值守被静默批准);可选「本次会话都允许」,关开关即失效 - 硬黑名单:删库/提权/管道下载执行/写系统路径/装开机项/摸凭据等, 用户点同意也不执行,连审批框都不弹。20 条危险命令 + 10 条正常命令单测 - 命令 cwd 锁沙箱根、60s 超时、输出 16KB 截断;非零退出不算失败(编译/测试错误对模型是有用信息) 【定时任务】sundynix_schedule + leader 锁 ticker(30s 扫) + 三个平台工具: - 存自然语言指令而非编排图,到点走语音同一条关卡(preflightCore/launchCore) 执行,跑完经语音事件主动播报结果 - 先推进 NextRunAt 再提交:提交失败也不会下轮重复捞起反复烧钱 - 停机期间错过的不补跑(补一堆历史提醒是骚扰),直接顺推到下一个未来时刻【顺带修一个必崩的 bug】dispatcher 工具超时硬编码 3 秒,而审批要等人点 (60s)+执行(60s)——local_exec 100% 超时。改成工具在 list_tools 自报 timeout_sec(不在 dispatcher 硬编码工具名),超时链外松内紧: dispatcher 160s > 网关 150s > runner 转发 140s > 桌面端 60+60s。 live 验证:①「写个 hello.sh 打印日期然后跑一下」→ 写+执行两步,文件真落磁盘 ②「建个定时任务 35 秒后跑 wc -l」→ 到点自动触发 → 自主调 local_exec → 出结果 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-07-25 13:57:49 +08:00
parent 52988af196
commit 348f1e0249
16 changed files with 832 additions and 25 deletions
@@ -30,7 +30,9 @@ var runnerUpgrader = websocket.Upgrader{
 }

 const (
-	runnerCallTimeout = 12 * time.Second // 等 runner 回执行结果（只读文件操作，够了）
+	// 等 runner 回执行结果。写文件/执行命令要等用户在桌面端点原生确认框（最长 60s）
+	// 再真跑（最长 60s），所以给到 140s；只读操作瞬时返回，不受影响。
+	runnerCallTimeout = 140 * time.Second
 	runnerWriteWait   = 10 * time.Second
 )

@@ -3,11 +3,14 @@ package handler
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"log"
 	"sort"
+	"strconv"
 	"strings"
 	"time"

+	"github.com/sundynix/sundynix-gateway/internal/store"
 	"github.com/sundynix/sundynix-shared/contract"
 )

@@ -28,12 +31,15 @@ type platParam struct {
 }

 // platTool 一个平台工具：元信息 + 处理函数（注册表 = 唯一事实源，dispatch 与 list_tools 共用）。
+// timeoutSec：自报超时预算（秒，0=用 dispatcher 默认 3 秒）。本地执行类要等用户点确认框
+// （人的反应时间）+ 真跑命令，必须自报更长预算，否则 3 秒必超时。
 type platTool struct {
-	cn      string
-	desc    string
-	params  []platParam
-	inject  []string
-	handler func(context.Context, *contract.ToolCall) *contract.ToolResult
+	cn         string
+	desc       string
+	params     []platParam
+	inject     []string
+	timeoutSec int
+	handler    func(context.Context, *contract.ToolCall) *contract.ToolResult
 }

 // platformRegistry 平台工具注册表。想加新工具（run_orchestration/search_kb/usage_today…）只改这里。
@@ -76,9 +82,146 @@ func (h *Handler) platformRegistry() map[string]platTool {
 			params: []platParam{{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true}},
 			inject: []string{"user_id"}, handler: h.platLocalExec,
 		},
+		// —— 能动的手：写文件 / 执行命令。桌面端会弹原生确认框让用户逐次批准（默认拒绝），
+		// 且命中安全黑名单的命令直接拒绝。被拒时如实告诉用户，别重试绕路。
+		"local_write_file": {
+			cn: "写本地文件", desc: "在用户本地工作目录内写入/覆盖一个文本文件。用户明确要求“写个文件/保存到本地/生成脚本”时调用。用户会在桌面端收到确认框，需其批准才真正写入。",
+			params: []platParam{
+				{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true},
+				{Name: "content", Type: "string", Desc: "完整文件内容（会覆盖原文件）", Required: true},
+			},
+			inject: []string{"user_id"}, timeoutSec: 100, handler: h.platLocalExec,
+		},
+		"local_exec": {
+			cn: "执行本地命令", desc: "在用户本地工作目录里执行一条 shell 命令并返回输出（超时 60 秒）。用户要求“跑一下/执行/编译/查一下某个命令结果”时调用。用户会在桌面端收到确认框，需其批准才执行；删库、提权、写系统路径等危险命令会被直接拒绝。一次只提交一条命令，别猜着连环执行。",
+			params: []platParam{{Name: "command", Type: "string", Desc: "要执行的 shell 命令，如 ls -la、git status、npm test", Required: true}},
+			inject: []string{"user_id"}, timeoutSec: 160, handler: h.platLocalExec,
+		},
+		// —— 调度：让用户能说「每天早上九点帮我看看昨天的任务」。到点由 JARVIS 自己按指令办事并播报。
+		"platform_schedule_create": {
+			cn: "建定时任务", desc: "创建一个定时/周期执行的任务。用户说“每天/每小时/几点钟 帮我做某事”“过 N 分钟提醒我”时调用。prompt 写清到点要做什么（就像用户当面对你说的那句话）。到点会自动执行并主动播报结果给用户。",
+			params: []platParam{
+				{Name: "title", Type: "string", Desc: "任务名，如「每日任务巡检」", Required: true},
+				{Name: "prompt", Type: "string", Desc: "到点要执行的指令原话，如「看看我昨天的任务都什么状态，有失败的告诉我」", Required: true},
+				{Name: "first_delay_sec", Type: "integer", Desc: "距首次执行的秒数。如「10 分钟后」填 600；如「明早9点」自己按当前时间算出秒数", Required: true},
+				{Name: "interval_sec", Type: "integer", Desc: "重复周期秒数（每天=86400，每小时=3600）；只跑一次填 0"},
+			},
+			inject: []string{"user_id", "tenant_id", "session_id"}, handler: h.platScheduleCreate,
+		},
+		"platform_schedule_list": {
+			cn: "看定时任务", desc: "列出当前用户的定时任务（含下次执行时间、是否启用）。用户问“我有哪些定时任务/提醒”时调用。",
+			inject: []string{"user_id"}, handler: h.platScheduleList,
+		},
+		"platform_schedule_cancel": {
+			cn: "取消定时任务", desc: "停用一条定时任务。用户说“取消/停掉那个定时任务”时调用；不知道 id 就先用 platform_schedule_list 查。",
+			params: []platParam{{Name: "id", Type: "string", Desc: "定时任务 ID", Required: true}},
+			inject: []string{"user_id"}, handler: h.platScheduleCancel,
+		},
 	}
 }

+// platScheduleCreate 建定时任务。首次执行时间由模型按"多少秒后"给出（它拿得到当前时间工具）。
+func (h *Handler) platScheduleCreate(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	if uid == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
+	}
+	title, _ := call.Args["title"].(string)
+	prompt, _ := call.Args["prompt"].(string)
+	if strings.TrimSpace(title) == "" || strings.TrimSpace(prompt) == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少任务名或执行指令"}
+	}
+	firstDelay := argInt(call.Args["first_delay_sec"])
+	interval := argInt(call.Args["interval_sec"])
+	if firstDelay < 10 {
+		firstDelay = 10 // 兜底：别让模型算出个立刻/过去的时刻
+	}
+	if interval > 0 && interval < 60 {
+		interval = 60 // 最短周期 1 分钟，防刷爆
+	}
+	tid, _ := call.Args["tenant_id"].(string)
+	sid, _ := call.Args["session_id"].(string)
+
+	s := &store.Schedule{
+		Owner: uid, TenantID: tid, SessionID: sid,
+		Title: title, Prompt: prompt,
+		IntervalSec: int64(interval), Enabled: true,
+		NextRunAt: time.Now().Add(time.Duration(firstDelay) * time.Second),
+	}
+	if err := h.db.CreateSchedule(ctx, s); err != nil {
+		return &contract.ToolResult{OK: false, Error: "创建定时任务失败: " + err.Error()}
+	}
+	every := "只执行一次"
+	if interval > 0 {
+		every = fmt.Sprintf("每 %d 分钟重复", interval/60)
+	}
+	data, _ := json.Marshal(map[string]string{
+		"id": s.ID, "title": title, "next_run": s.NextRunAt.Format("01-02 15:04"), "repeat": every,
+		"msg": "已建好定时任务。告诉用户首次执行时间即可，到点会自动执行并主动播报结果。",
+	})
+	return &contract.ToolResult{OK: true, Content: string(data)}
+}
+
+func (h *Handler) platScheduleList(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	if uid == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
+	}
+	rows := h.db.ListSchedules(ctx, uid)
+	if len(rows) == 0 {
+		return &contract.ToolResult{OK: true, Content: "当前没有任何定时任务。"}
+	}
+	type item struct {
+		ID      string `json:"id"`
+		Title   string `json:"title"`
+		Next    string `json:"next_run,omitempty"`
+		Repeat  string `json:"repeat"`
+		Enabled bool   `json:"enabled"`
+		Runs    int64  `json:"run_count"`
+	}
+	out := make([]item, 0, len(rows))
+	for _, r := range rows {
+		rep := "一次性"
+		if r.IntervalSec > 0 {
+			rep = fmt.Sprintf("每 %d 分钟", r.IntervalSec/60)
+		}
+		it := item{ID: r.ID, Title: r.Title, Repeat: rep, Enabled: r.Enabled, Runs: r.RunCount}
+		if r.Enabled {
+			it.Next = r.NextRunAt.Format("01-02 15:04")
+		}
+		out = append(out, it)
+	}
+	data, _ := json.Marshal(out)
+	return &contract.ToolResult{OK: true, Content: string(data)}
+}
+
+func (h *Handler) platScheduleCancel(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	id, _ := call.Args["id"].(string)
+	if uid == "" || strings.TrimSpace(id) == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少定时任务 ID"}
+	}
+	// CancelSchedule 的 WHERE 带 owner，天然拦住改别人的任务。
+	if err := h.db.CancelSchedule(ctx, uid, id); err != nil {
+		return &contract.ToolResult{OK: false, Error: "取消失败: " + err.Error()}
+	}
+	return &contract.ToolResult{OK: true, Content: "已停用该定时任务（若 ID 不属于当前用户则无事发生）。"}
+}
+
+// argInt 把模型给的数字参数（JSON 里可能是 float64/string）转成 int。
+func argInt(v any) int {
+	switch n := v.(type) {
+	case float64:
+		return int(n)
+	case int:
+		return n
+	case string:
+		i, _ := strconv.Atoi(strings.TrimSpace(n))
+		return i
+	}
+	return 0
+}
+
 // platLocalExec 把 local_* 调用经 NATS 路由到该用户的桌面 runner（见 local_runner.go）。
 // 无 runner 在线时 NATS 无应答 → 明确报"不在线"，绝不挂起任务。
 func (h *Handler) platLocalExec(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
@@ -86,7 +229,9 @@ func (h *Handler) platLocalExec(ctx context.Context, call *contract.ToolCall) *c
 	if uid == "" {
 		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
 	}
-	cctx, cancel := context.WithTimeout(ctx, 15*time.Second)
+	// 超时链必须外松内紧：dispatcher(160s) > 这里(150s) > runner 转发(140s) > 桌面端审批60s+执行60s。
+	// 任一层比内层短，用户还在看确认框就被判超时。
+	cctx, cancel := context.WithTimeout(ctx, 150*time.Second)
 	defer cancel()
 	res, err := h.bus.CallTool(cctx, contract.LocalExecSubject(uid), call)
 	if err != nil {
@@ -130,16 +275,20 @@ func (h *Handler) platformDispatch(reg map[string]platTool, ctx context.Context,
 // platListTools 自省：JSON 契约与 mcp-go listTools 一致（dispatcher toolCatalogEntry 同一解析）。
 func platListTools(reg map[string]platTool) *contract.ToolResult {
 	type info struct {
-		Name   string      `json:"name"`
-		CN     string      `json:"cn"`
-		Desc   string      `json:"desc"`
-		Agent  bool        `json:"agent_exposed"`
-		Params []platParam `json:"params,omitempty"`
-		Inject []string    `json:"inject,omitempty"`
+		Name    string      `json:"name"`
+		CN      string      `json:"cn"`
+		Desc    string      `json:"desc"`
+		Agent   bool        `json:"agent_exposed"`
+		Params  []platParam `json:"params,omitempty"`
+		Inject  []string    `json:"inject,omitempty"`
+		Timeout int         `json:"timeout_sec,omitempty"`
 	}
 	out := make([]info, 0, len(reg))
 	for name, td := range reg {
-		out = append(out, info{Name: name, CN: td.cn, Desc: td.desc, Agent: true, Params: td.params, Inject: td.inject})
+		out = append(out, info{
+			Name: name, CN: td.cn, Desc: td.desc, Agent: true,
+			Params: td.params, Inject: td.inject, Timeout: td.timeoutSec,
+		})
 	}
 	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
 	data, _ := json.Marshal(map[string]any{"service": "gateway-platform", "tools": out})
@@ -0,0 +1,134 @@
+package handler
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/sundynix/sundynix-gateway/internal/dsl"
+	"github.com/sundynix/sundynix-gateway/internal/store"
+	"github.com/sundynix/sundynix-shared/contract"
+)
+
+// 定时任务触发器（JARVIS 调度能力）：到点把用户存的那句自然语言指令交给 JARVIS 去办，
+// 走的正是语音/HTTP 同一条关卡（preflightCore + launchCore），跑完经语音事件主动播报。
+//
+// 与订阅推进（subscription_tick.go）同一范式：safeGo + leader 锁 + 单轮 panic 兜底。
+// 幂等靠"先推进 NextRunAt 再提交"——同一条到期任务不会被两轮重复捞起。
+
+const (
+	scheduleTickInterval        = 30 * time.Second
+	scheduleLeaderKey    int64  = 20260725
+	scheduleBatchLimit          = 20 // 单轮最多跑几条，防积压时打爆 LLM
+)
+
+// StartScheduleTicker 随进程生命周期运行；多副本下只有抢到 advisory 锁的实例真正扫。
+func (h *Handler) StartScheduleTicker(ctx context.Context) {
+	safeGo("schedule-ticker", func() {
+		t := time.NewTicker(scheduleTickInterval)
+		defer t.Stop()
+		runTick := func() {
+			safeCall("schedule-tick", func() {
+				h.db.TryRunExclusive(ctx, scheduleLeaderKey, func() { h.tickSchedules(ctx) })
+			})
+		}
+		runTick()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-t.C:
+				runTick()
+			}
+		}
+	})
+}
+
+func (h *Handler) tickSchedules(ctx context.Context) {
+	due := h.db.DueSchedules(ctx, scheduleBatchLimit)
+	for i := range due {
+		s := due[i]
+		// 先推进再提交：即使下面提交失败，也不会在下一轮被重复捞起反复烧钱。
+		if err := h.db.AdvanceSchedule(ctx, &s); err != nil {
+			log.Printf("[schedule] 推进失败 id=%s: %v", s.ID, err)
+			continue
+		}
+		if taskID, err := h.runSchedule(ctx, &s); err != nil {
+			log.Printf("[schedule] 执行失败 id=%s owner=%s: %v", s.ID, s.Owner, err)
+			// 提交失败（余额不足/租户暂停等）也告诉用户一声，别让定时任务静默消失。
+			h.announceToUser(s.Owner, "定时任务「"+s.Title+"」这次没能执行："+err.Error())
+		} else {
+			log.Printf("[schedule] 已触发 id=%s title=%s task=%s", s.ID, s.Title, taskID)
+		}
+	}
+}
+
+// runSchedule 把一条定时任务的自然语言指令提交成一次 JARVIS 执行。
+func (h *Handler) runSchedule(ctx context.Context, s *store.Schedule) (string, error) {
+	// 复用语音图：input(指令) → autonomous agent(带平台/本地全套工具)。
+	// 定时任务本质就是"替用户说了这句话"，执行路径与语音完全一致，不另起炉灶。
+	raw := buildVoiceGraph(s.Prompt, defaultJarvisName, "这是一条定时任务，请直接把结果讲清楚，简短。")
+	task, err := dsl.ParseAndAssemble(raw)
+	if err != nil {
+		return "", err
+	}
+	billingTenant, block := h.preflightCore(ctx, s.Owner, s.TenantID)
+	if block != nil {
+		return "", errScheduleBlocked{block.message()}
+	}
+	task.Meta[contract.MetaUserID] = s.Owner
+	task.Meta[contract.MetaTenantID] = billingTenant
+	task.Meta[contract.MetaSessionID] = s.SessionID
+	task.Meta[contract.MetaModelProfile] = contract.ModelProfileVoice
+	if err := h.launchCore(ctx, s.Owner, task); err != nil {
+		return "", err
+	}
+	// 结果播报：订阅这次任务的 token 流，攒完整答复后经语音事件推给用户（没开语音则静默丢弃）。
+	go h.announceScheduleResult(task.ID, s.Title)
+	return task.ID, nil
+}
+
+type errScheduleBlocked struct{ msg string }
+
+func (e errScheduleBlocked) Error() string { return e.msg }
+
+// announceScheduleResult 等这次定时任务的回答产出完，把结果主动播报给用户。
+func (h *Handler) announceScheduleResult(taskID, title string) {
+	done := make(chan string, 1)
+	var buf []byte
+	unsub, err := h.bus.SubscribeTokens(taskID,
+		func(tok []byte) { buf = append(buf, tok...) },
+		func() { done <- string(buf) },
+	)
+	if err != nil {
+		return
+	}
+	defer func() { _ = unsub() }()
+
+	select {
+	case answer := <-done:
+		if answer == "" {
+			return
+		}
+		if r := []rune(answer); len(r) > 300 { // 播报别太长，语音场景听不完
+			answer = string(r[:300]) + "…"
+		}
+		h.announceToUser(ownerOfTask(h, taskID), "定时任务「"+title+"」的结果：" + answer)
+	case <-time.After(5 * time.Minute):
+	}
+}
+
+// ownerOfTask 查任务归属（播报要发给正确的人）。
+func ownerOfTask(h *Handler, taskID string) string {
+	return h.db.TaskOwner(context.Background(), taskID)
+}
+
+// announceToUser 经语音事件通道给用户播报一句（无在线语音会话则静默丢弃）。
+func (h *Handler) announceToUser(uid, text string) {
+	if uid == "" || text == "" {
+		return
+	}
+	if err := h.bus.PublishVoiceEvent(uid, &contract.VoiceEvent{Action: "announce", Text: text}); err != nil {
+		log.Printf("[schedule] 播报失败 uid=%s: %v", uid, err)
+	}
+}
@@ -25,8 +25,13 @@ func voiceSystemPrompt(name, persona string) string {
 	if n == "" {
 		n = defaultJarvisName
 	}
-	s := "你是 " + n + "——用户的私人语音助手，也是这套平台的中枢：你能直接查用户最近的任务、" +
-		"查某个任务的状态和结果、派发报告生成任务（相应工具会提供给你，需要就调，别凭空编造任务状态）。" +
+	s := "你是 " + n + "——用户的私人语音助手，也是这套平台与他电脑的中枢。你能：查/派任务与报告、" +
+		"切换客户端界面、在用户授权的工作目录里看文件读文件、写文件、执行 shell 命令、" +
+		"以及建定时任务（到点自动办事并播报）。相应工具会提供给你，需要就调。" +
+		"铁律一：凡是用户问任务/报告的状态、进度、结果，**必须先调工具查真实数据再回答**——" +
+		"哪怕你觉得自己记得，也不许凭记忆或上下文编造任务状态；查不到就如实说查不到。" +
+		"铁律二：涉及写文件/执行命令，用户会在电脑上收到确认框；被拒绝或被安全策略挡下时如实告诉他，" +
+		"不要换个写法绕过去重试。定时任务要算首次执行还有多少秒，先用时间工具拿当前时间再算。" +
 		"这是语音对话，务必简短：先直接给结论，一两句话说清，通常不超过三句，别铺垫、别列清单、" +
 		"别念代码、别复述问题。口语化、自然。派了任务就告诉用户已开跑、稍后可以问进度，不要干等。"
 	if p := strings.TrimSpace(persona); p != "" {