feat(jarvis): 本地沙箱改多目录白名单 + 让它知道自己能操作这台电脑

单目录沙箱做不了"操作我电脑"——只能在一个文件夹里打转,跨目录整理直接没戏。
且模型压根不知道 shell 除了跑脚本还能开 App、控 App、触发快捷指令。

沙箱：单根 → 多根白名单
- 用户授权多个目录（设置里每行一个，可一键填入桌面/下载/文档），其余一律拒
- 路径改绝对路径（多根之下相对路径没有唯一含义），支持 ~ 展开，相对路径兜底按首个根解释
- local_list_dir 留空 path = 返回授权目录清单 → 模型据此自己发现"我能访问哪儿"
- local_exec 可指定 cwd（须在授权目录内）
- 防逃逸不变：软链解析后必须落在某个根内，越界即拒（单测覆盖 ../ 与软链逃逸）

告诉模型它能干什么
- local_exec 描述展开：文件整理(mv/cp/find)、mdfind 全盘搜、open 开应用/文件/网址、
  osascript 控制 Mac App、shortcuts run/list 触发快捷指令、系统信息
- 语音系统提示词把 JARVIS 定位成"这台电脑的操作者"，并要求先想清用哪个工具再动手

live 验证（两个授权目录）：
① "你能访问哪些目录，里面有什么" → 自主先查授权清单、再逐个列举，答全对
② "把下载里的图片挪到桌面" → 自主 mv，文件真的跨目录移动了

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

sundynix-desktop/frontend/bindings/github.com/sundynix/sundynix-desktop/app.ts

@@ -12,6 +12,13 @@
 // @ts-ignore: Unused imports
 import { Call as $Call, CancellablePromise as $CancellablePromise, Create as $Create } from "@wailsio/runtime";
 
+/**
+ * DefaultLocalDirs 返回建议授权的常用目录（桌面/下载/文档），供设置界面一键填入。
+ */
+export function DefaultLocalDirs(): $CancellablePromise<string> {
+    return $Call.ByID(2376992125);
+}
+
 /**
  * LocalExecEnabled 供前端显示开关状态。
  */
@@ -66,11 +73,11 @@ export function SetLocalExecEnabled(on: boolean): $CancellablePromise<void> {
 }
 
 /**
- * StartLocalRunner 开启本地文件访问：以 workdir 为沙箱根连接 gateway 注册执行器。
+ * StartLocalRunner 开启本地访问：dirs 是换行分隔的授权目录列表（沙箱白名单）。
  * 幂等：重复调用先停旧连接。断线自动重连（5s 退避）直到 StopLocalRunner。
  */
-export function StartLocalRunner(gatewayURL: string, token: string, workdir: string): $CancellablePromise<void> {
+export function StartLocalRunner(gatewayURL: string, token: string, dirs: string): $CancellablePromise<void> {
-    return $Call.ByID(2808780368, gatewayURL, token, workdir);
+    return $Call.ByID(2808780368, gatewayURL, token, dirs);
 }
 
 /**

sundynix-desktop/frontend/src/lib/desktop.ts

@@ -33,10 +33,16 @@ export function localRunnerAvailable(): boolean {
   return inWails();
 }
 
-// startLocalRunner：以 workdir 为沙箱根开启本地文件访问（Go host 连 gateway 注册执行器）。
+// startLocalRunner：以 dirs（换行分隔的多个目录）为沙箱白名单开启本地访问。
-export async function startLocalRunner(gatewayURL: string, token: string, workdir: string): Promise<void> {
+export async function startLocalRunner(gatewayURL: string, token: string, dirs: string): Promise<void> {
-  if (!inWails()) throw new Error("本地文件访问仅桌面端可用");
+  if (!inWails()) throw new Error("本地访问仅桌面端可用");
-  await App.StartLocalRunner(gatewayURL, token, workdir);
+  await App.StartLocalRunner(gatewayURL, token, dirs);
+}
+
+// defaultLocalDirs：桌面/下载/文档的绝对路径（换行分隔），供一键填入。
+export async function defaultLocalDirs(): Promise<string> {
+  if (!inWails()) return "";
+  return App.DefaultLocalDirs();
 }
 
 export function stopLocalRunner(): void {

sundynix-desktop/frontend/src/shell/JarvisSettings.tsx

@@ -4,6 +4,7 @@ import { Button } from "../ui/Button";
 import { useToast } from "../ui/Toast";
 import { getMyJarvis, saveMyJarvis, type JarvisConfig, GATEWAY, getToken } from "../lib/api";
 import {
+  defaultLocalDirs,
   localExecEnabled,
   localRunnerAvailable,
   localRunnerStatus,
@@ -155,10 +156,10 @@ function LocalAccessSection() {
         stopLocalRunner();
         setStatus("offline");
       } else {
-        if (!dir.trim()) throw new Error("先填一个允许 JARVIS 访问的本地目录（绝对路径）");
+        if (!dir.trim()) throw new Error("至少填一个允许 JARVIS 访问的目录（绝对路径，每行一个）");
         await startLocalRunner(GATEWAY, getToken(), dir.trim());
         setStatus("connecting");
-        toast.push("success", "本地文件访问已开启（只读，锁定在该目录内）");
+        toast.push("success", "本地访问已开启（仅限授权目录）");
       }
     } catch (e) {
       toast.push("error", (e as Error).message);
@@ -170,24 +171,39 @@ function LocalAccessSection() {
   return (
     <div className="space-y-2 rounded-md border border-line bg-ink-900/50 p-3">
       <div className="flex items-center justify-between">
-        <span className="text-xs text-slate-400">本地文件访问（试验 · 只读）</span>
+        <span className="text-xs text-slate-400">本地访问（授权目录）</span>
         <span className={online ? "text-[11px] text-emerald-400" : "text-[11px] text-slate-500"}>
           {online ? "已开启" : status === "connecting" ? "连接中…" : "未开启"}
         </span>
       </div>
       <p className="text-[11px] leading-relaxed text-slate-500">
-        开启后 JARVIS 能<b>查看/读取</b>下面这个目录里的文件（仅此目录，不能写、不能执行命令）。
+        JARVIS 只能在你授权的这些目录里活动（其余一律拒绝）。开启后可以说
-        对话里可以说“看看我工作目录里有什么”。
+        “看看我桌面上有什么”“把下载里的图片整理一下”。默认只读；要让它动手改文件、跑命令，
+        还得单独打开下面那个开关。
       </p>
       {online ? (
-        <p className="break-all font-mono text-[11px] text-slate-400">{status.slice("online:".length)}</p>
+        <div className="space-y-0.5">
+          {status.slice("online:".length).split("\n").filter(Boolean).map((d) => (
+            <p key={d} className="break-all font-mono text-[11px] text-slate-400">· {d}</p>
+          ))}
+        </div>
       ) : (
-        <input
+        <>
-          className="w-full rounded-md border border-line bg-ink-850 px-3 py-1.5 font-mono text-sm text-slate-100 focus:border-brand focus:outline-none"
+          <textarea
-          value={dir}
+            rows={3}
-          onChange={(e) => setDir(e.target.value)}
+            className="w-full resize-none rounded-md border border-line bg-ink-850 px-3 py-1.5 font-mono text-xs text-slate-100 focus:border-brand focus:outline-none"
-          placeholder="/Users/你/Documents/某个目录"
+            value={dir}
-        />
+            onChange={(e) => setDir(e.target.value)}
+            placeholder={"每行一个目录（绝对路径），例：\n/Users/你/Desktop\n/Users/你/Downloads"}
+          />
+          <button
+            type="button"
+            className="text-[11px] text-brand-400 transition hover:underline"
+            onClick={() => void defaultLocalDirs().then((d) => d && setDir(d))}
+          >
+            + 填入常用目录（桌面 / 下载 / 文档）
+          </button>
+        </>
       )}
       <Button variant={online ? "ghost" : "secondary"} size="sm" onClick={onToggle} disabled={busy}>
         {online || status === "connecting" ? "关闭本地访问" : "开启本地访问"}

sundynix-desktop/localexec.go

@@ -131,7 +131,7 @@ func askApproval(title, detail string) bool {
 }
 
 // execWrite 写文件（沙箱内 + 审批）。
-func execWrite(root string, req *runnerReq) *runnerResp {
+func execWrite(roots []string, req *runnerReq) *runnerResp {
 	fail := func(m string) *runnerResp { return &runnerResp{ID: req.ID, OK: false, Error: m} }
 	if !execAllowed() {
 		return fail("用户未开启「允许执行命令与写文件」。请如实告知用户需要在 JARVIS 设置里打开。")
@@ -141,7 +141,7 @@ func execWrite(root string, req *runnerReq) *runnerResp {
 	if strings.TrimSpace(rel) == "" {
 		return fail("缺少文件路径")
 	}
-	p, err := resolveInRoot(root, rel)
+	p, err := resolveAllowed(roots, rel)
 	if err != nil {
 		return fail(err.Error())
 	}
@@ -162,7 +162,7 @@ func execWrite(root string, req *runnerReq) *runnerResp {
 }
 
 // execCommand 在沙箱工作目录里跑一条命令（黑名单 + 审批 + 超时 + 输出截断）。
-func execCommand(root string, req *runnerReq) *runnerResp {
+func execCommand(roots []string, req *runnerReq) *runnerResp {
 	fail := func(m string) *runnerResp { return &runnerResp{ID: req.ID, OK: false, Error: m} }
 	if !execAllowed() {
 		return fail("用户未开启「允许执行命令与写文件」。请如实告知用户需要在 JARVIS 设置里打开。")
@@ -175,14 +175,26 @@ func execCommand(root string, req *runnerReq) *runnerResp {
 	if reason := checkDenied(cmdStr); reason != "" {
 		return fail(reason) // 硬拒：连审批框都不弹
 	}
-	if !askApproval("JARVIS 想在你的电脑上执行命令", "工作目录："+root+"\n\n命令：\n"+cmdStr) {
+	cwd := ""
+	if len(roots) > 0 {
+		cwd = roots[0]
+	}
+	// 模型可指定在哪个授权目录里跑（不给就用第一个）；越界目录直接拒。
+	if d, _ := req.Args["cwd"].(string); strings.TrimSpace(d) != "" {
+		resolved, rerr := resolveAllowed(roots, d)
+		if rerr != nil {
+			return fail(rerr.Error())
+		}
+		cwd = resolved
+	}
+	if !askApproval("JARVIS 想在你的电脑上执行命令", "工作目录："+cwd+"\n\n命令：\n"+cmdStr) {
 		return fail("用户拒绝了这次执行。")
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), execTimeout)
 	defer cancel()
 	c := exec.CommandContext(ctx, "/bin/sh", "-c", cmdStr)
-	c.Dir = root // 工作目录锁在沙箱根
+	c.Dir = cwd // 工作目录锁在授权目录内
 	out, err := c.CombinedOutput()
 	text := string(out)
 	if len(text) > execMaxOutput {

sundynix-desktop/localexec_test.go

@@ -62,10 +62,10 @@ func TestExecDeniedWhenSwitchOff(t *testing.T) {
 	gate.mu.Unlock()
 
 	root := t.TempDir()
-	if r := execCommand(root, &runnerReq{ID: "1", Tool: "local_exec", Args: map[string]any{"command": "ls"}}); r.OK {
+	if r := execCommand([]string{root}, &runnerReq{ID: "1", Tool: "local_exec", Args: map[string]any{"command": "ls"}}); r.OK {
 		t.Fatal("开关关闭时命令仍被执行")
 	}
-	if r := execWrite(root, &runnerReq{ID: "2", Tool: "local_write_file", Args: map[string]any{"path": "x.txt", "content": "y"}}); r.OK {
+	if r := execWrite([]string{root}, &runnerReq{ID: "2", Tool: "local_write_file", Args: map[string]any{"path": "x.txt", "content": "y"}}); r.OK {
 		t.Fatal("开关关闭时写入仍被执行")
 	}
 }
@@ -82,7 +82,7 @@ func TestDenylistPrecedesApproval(t *testing.T) {
 		gate.mu.Unlock()
 	}()
 
-	r := execCommand(t.TempDir(), &runnerReq{ID: "1", Tool: "local_exec", Args: map[string]any{"command": "sudo rm -rf /"}})
+	r := execCommand([]string{t.TempDir()}, &runnerReq{ID: "1", Tool: "local_exec", Args: map[string]any{"command": "sudo rm -rf /"}})
 	if r.OK {
 		t.Fatal("黑名单命令未被拒绝")
 	}

sundynix-desktop/localrunner.go

@@ -16,11 +16,12 @@ import (
 
 // 本地执行 runner（JARVIS「本地的手」，LOCAL_AGENT_DESIGN 档 A / JARVIS_BRAIN_DESIGN P4）：
 // 桌面端 Go host 连 gateway 的 /api/v1/local/runner WS，把自己注册成本用户的本地执行器；
-// 服务端把 local_* 工具调用转发过来，这里在**用户自选工作目录的沙箱内**执行并回结果。
+// 服务端把 local_* 工具调用转发过来，这里在**用户授权目录的沙箱内**执行并回结果。
 //
-// 安全铁律（P1 只读起步）：
+// 安全铁律：
-//   - 只实现 list_dir / read_file，无写无 exec；
+//   - 多目录白名单：用户授权哪些目录（桌面/下载/文档/项目…），就只能动这些目录，其余一律拒；
-//   - 一切路径锁死在用户显式选择的 workdir 根下（清洗 + 软链解析后前缀校验，越界即拒）；
+//   - 防逃逸靠软链解析后前缀校验（软链指向白名单外也拒）；
+//   - 写文件/执行命令另有独立开关 + 硬黑名单 + 逐次原生确认框（见 localexec.go）；
 //   - 用户不点"开启"，runner 永不连接——本地访问是显式授权，不是默认能力。
 
 type runnerReq struct {
@@ -39,37 +40,69 @@ type runnerResp struct {
 
 // LocalRunner 管一条 runner 连接的生命周期（App 持有单例）。
 type LocalRunner struct {
-	mu      sync.Mutex
+	mu     sync.Mutex
-	cancel  context.CancelFunc
+	cancel context.CancelFunc
-	workdir string
+	roots  []string // 已授权目录白名单（绝对路径）
-	status  string // offline / connecting / online
+	status string   // offline / connecting / online
 }
 
-// StartLocalRunner 开启本地文件访问：以 workdir 为沙箱根连接 gateway 注册执行器。
+// StartLocalRunner 开启本地访问：dirs 是换行分隔的授权目录列表（沙箱白名单）。
 // 幂等：重复调用先停旧连接。断线自动重连（5s 退避）直到 StopLocalRunner。
-func (a *App) StartLocalRunner(gatewayURL, token, workdir string) error {
+func (a *App) StartLocalRunner(gatewayURL, token, dirs string) error {
-	abs, err := filepath.Abs(strings.TrimSpace(workdir))
+	var roots []string
-	if err != nil {
+	for _, line := range strings.Split(dirs, "\n") {
-		return fmt.Errorf("工作目录无效: %w", err)
+		d := strings.TrimSpace(line)
+		if d == "" {
+			continue
+		}
+		if d == "~" || strings.HasPrefix(d, "~/") {
+			if home, err := os.UserHomeDir(); err == nil {
+				d = filepath.Join(home, strings.TrimPrefix(strings.TrimPrefix(d, "~"), "/"))
+			}
+		}
+		abs, err := filepath.Abs(d)
+		if err != nil {
+			return fmt.Errorf("目录无效: %s", d)
+		}
+		if fi, err := os.Stat(abs); err != nil || !fi.IsDir() {
+			return fmt.Errorf("目录不存在或不是目录: %s", abs)
+		}
+		roots = append(roots, abs)
 	}
-	if fi, err := os.Stat(abs); err != nil || !fi.IsDir() {
+	if len(roots) == 0 {
-		return fmt.Errorf("工作目录不存在或不是目录: %s", abs)
+		return fmt.Errorf("至少要授权一个目录")
 	}
 	a.runner.stop()
 
 	ctx, cancel := context.WithCancel(context.Background())
 	a.runner.mu.Lock()
 	a.runner.cancel = cancel
-	a.runner.workdir = abs
+	a.runner.roots = roots
 	a.runner.status = "connecting"
 	a.runner.mu.Unlock()
 
 	wsURL := strings.Replace(strings.TrimRight(gatewayURL, "/"), "http", "ws", 1) +
 		"/api/v1/local/runner?token=" + token
-	go a.runner.loop(ctx, wsURL, abs)
+	go a.runner.loop(ctx, wsURL, roots)
 	return nil
 }
 
+// DefaultLocalDirs 返回建议授权的常用目录（桌面/下载/文档），供设置界面一键填入。
+func (a *App) DefaultLocalDirs() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	var out []string
+	for _, name := range []string{"Desktop", "Downloads", "Documents"} {
+		p := filepath.Join(home, name)
+		if fi, err := os.Stat(p); err == nil && fi.IsDir() {
+			out = append(out, p)
+		}
+	}
+	return strings.Join(out, "\n")
+}
+
 // StopLocalRunner 关闭本地文件访问（幂等）。
 func (a *App) StopLocalRunner() { a.runner.stop() }
 
@@ -78,7 +111,7 @@ func (a *App) LocalRunnerStatus() string {
 	a.runner.mu.Lock()
 	defer a.runner.mu.Unlock()
 	if a.runner.status == "online" {
-		return "online:" + a.runner.workdir
+		return "online:" + strings.Join(a.runner.roots, "\n")
 	}
 	return a.runner.status
 }
@@ -100,9 +133,9 @@ func (r *LocalRunner) setStatus(s string) {
 }
 
 // loop 连接→服务→断线重连（5s 退避），直到 ctx 取消。
-func (r *LocalRunner) loop(ctx context.Context, wsURL, root string) {
+func (r *LocalRunner) loop(ctx context.Context, wsURL string, roots []string) {
 	for {
-		if err := r.serve(ctx, wsURL, root); err != nil && ctx.Err() == nil {
+		if err := r.serve(ctx, wsURL, roots); err != nil && ctx.Err() == nil {
 			r.setStatus("connecting")
 		}
 		select {
@@ -115,7 +148,7 @@ func (r *LocalRunner) loop(ctx context.Context, wsURL, root string) {
 }
 
 // serve 一条连接的会话：发 hello → 循环收请求、沙箱内执行、回结果。
-func (r *LocalRunner) serve(ctx context.Context, wsURL, root string) error {
+func (r *LocalRunner) serve(ctx context.Context, wsURL string, roots []string) error {
 	dctx, dcancel := context.WithTimeout(ctx, 10*time.Second)
 	conn, _, err := websocket.Dial(dctx, wsURL, nil)
 	dcancel()
@@ -126,7 +159,7 @@ func (r *LocalRunner) serve(ctx context.Context, wsURL, root string) error {
 	conn.SetReadLimit(1 << 20)
 	r.setStatus("online")
 
-	hello, _ := json.Marshal(runnerResp{ID: "hello", OK: true, Workdir: root})
+	hello, _ := json.Marshal(runnerResp{ID: "hello", OK: true, Workdir: strings.Join(roots, "、")})
 	if err := conn.Write(ctx, websocket.MessageText, hello); err != nil {
 		return err
 	}
@@ -140,7 +173,7 @@ func (r *LocalRunner) serve(ctx context.Context, wsURL, root string) error {
 		if json.Unmarshal(data, &req) != nil {
 			continue
 		}
-		resp := execLocal(root, &req)
+		resp := execLocal(roots, &req)
 		out, _ := json.Marshal(resp)
 		if err := conn.Write(ctx, websocket.MessageText, out); err != nil {
 			return err
@@ -155,10 +188,33 @@ const (
 	maxDirEntries = 200       // list_dir 上限条数
 )
 
-// resolveInRoot 把相对路径解析进沙箱根：清洗 + 软链解析后必须仍在 root 下，越界即错。
+// resolveAllowed 把一个路径解析并校验是否落在**任一**授权目录内。
-func resolveInRoot(root, rel string) (string, error) {
+// 单目录沙箱做不了"操作我电脑"（只能在一个文件夹里打转），改成多目录白名单：
-	p := filepath.Join(root, filepath.Clean("/"+rel)) // 前置 "/" 再 Clean：吃掉 ../ 逃逸
+// 用户授权哪些目录（桌面/下载/文档/项目目录…），agent 就只能在这些目录里动手。
-	// 软链解析（目标可能不存在：解析其父目录）
+// 路径用绝对路径（多根之下相对路径没有唯一含义），支持 ~ 展开。
+// 防逃逸仍靠"软链解析后前缀校验"——软链指向白名单之外一律拒。
+func resolveAllowed(roots []string, p string) (string, error) {
+	p = strings.TrimSpace(p)
+	if p == "" {
+		return "", fmt.Errorf("缺少路径")
+	}
+	if p == "~" || strings.HasPrefix(p, "~/") {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		p = filepath.Join(home, strings.TrimPrefix(strings.TrimPrefix(p, "~"), "/"))
+	}
+	if !filepath.IsAbs(p) {
+		// 相对路径按第一个授权目录解释（兜底：模型偶尔会给相对路径）
+		if len(roots) == 0 {
+			return "", fmt.Errorf("没有已授权的目录")
+		}
+		p = filepath.Join(roots[0], filepath.Clean("/"+p))
+	}
+	p = filepath.Clean(p)
+
+	// 软链解析（目标可能不存在：那就用清洗后的路径本身比对）
 	resolved, err := filepath.EvalSymlinks(p)
 	if err != nil {
 		if !os.IsNotExist(err) {
@@ -166,23 +222,34 @@ func resolveInRoot(root, rel string) (string, error) {
 		}
 		resolved = p
 	}
-	rootR, err := filepath.EvalSymlinks(root)
+	for _, root := range roots {
-	if err != nil {
+		rootR, err := filepath.EvalSymlinks(root)
-		rootR = root
+		if err != nil {
+			rootR = root
+		}
+		if resolved == rootR || strings.HasPrefix(resolved, rootR+string(filepath.Separator)) {
+			return resolved, nil
+		}
 	}
-	if resolved != rootR && !strings.HasPrefix(resolved, rootR+string(filepath.Separator)) {
+	return "", fmt.Errorf("路径 %s 不在已授权目录内（当前授权：%s）", p, strings.Join(roots, "、"))
-		return "", fmt.Errorf("路径越出工作目录沙箱")
-	}
-	return resolved, nil
 }
 
-func execLocal(root string, req *runnerReq) *runnerResp {
+func execLocal(roots []string, req *runnerReq) *runnerResp {
 	fail := func(msg string) *runnerResp { return &runnerResp{ID: req.ID, OK: false, Error: msg} }
 	rel, _ := req.Args["path"].(string)
 
 	switch req.Tool {
 	case "local_list_dir":
-		p, err := resolveInRoot(root, rel)
+		// 空路径 = 列出所有已授权目录（多根之下没有唯一"根"）。
+		// 这也是模型发现"我能访问哪些地方"的入口。
+		if strings.TrimSpace(rel) == "" {
+			data, _ := json.Marshal(map[string]any{
+				"authorized_dirs": roots,
+				"hint":            "这些是用户授权可访问的目录。要看某个目录内容，把它的绝对路径作为 path 再调一次。",
+			})
+			return &runnerResp{ID: req.ID, OK: true, Content: string(data)}
+		}
+		p, err := resolveAllowed(roots, rel)
 		if err != nil {
 			return fail(err.Error())
 		}
@@ -214,7 +281,7 @@ func execLocal(root string, req *runnerReq) *runnerResp {
 		if strings.TrimSpace(rel) == "" {
 			return fail("缺少文件路径")
 		}
-		p, err := resolveInRoot(root, rel)
+		p, err := resolveAllowed(roots, rel)
 		if err != nil {
 			return fail(err.Error())
 		}
@@ -240,10 +307,10 @@ func execLocal(root string, req *runnerReq) *runnerResp {
 
 	// 能动的手（localexec.go）：各自带独立开关 + 黑名单 + 原生审批框。
 	case "local_write_file":
-		return execWrite(root, req)
+		return execWrite(roots, req)
 
 	case "local_exec":
-		return execCommand(root, req)
+		return execCommand(roots, req)
 
 	default:
 		return fail("本地执行器不支持该操作: " + req.Tool)

sundynix-desktop/localrunner_test.go

@@ -34,7 +34,7 @@ func TestResolveInRootBlocksEscape(t *testing.T) {
 		rootR = root
 	}
 	for _, rel := range []string{"..", "../..", "../../etc/passwd", "sub/../../outside", "/etc/passwd"} {
-		p, err := resolveInRoot(root, rel)
+		p, err := resolveAllowed([]string{root}, rel)
 		// 前置 "/"+Clean 把绝对路径/.. 都钉回 root 下（如 root/etc/passwd，不算逃逸）；
 		// 无论哪种形式，成功解析的结果都必须仍在 root（解析后）之内。
 		if err == nil && p != rootR && !strings.HasPrefix(p, rootR+string(filepath.Separator)) {
@@ -53,7 +53,7 @@ func TestResolveInRootBlocksSymlinkEscape(t *testing.T) {
 	if err := os.Symlink(outside, link); err != nil {
 		t.Skip("无法创建软链，跳过")
 	}
-	if _, err := resolveInRoot(root, "evil/secret.txt"); err == nil {
+	if _, err := resolveAllowed([]string{root}, "evil/secret.txt"); err == nil {
 		t.Fatal("软链逃逸未被拦截")
 	}
 }
@@ -61,8 +61,14 @@ func TestResolveInRootBlocksSymlinkEscape(t *testing.T) {
 func TestExecLocalListAndRead(t *testing.T) {
 	root := newSandbox(t)
 
-	// list_dir 根目录
+	// list_dir 空路径 = 列出授权目录清单（模型据此发现能访问哪里）
-	resp := execLocal(root, &runnerReq{ID: "1", Tool: "local_list_dir", Args: map[string]any{"path": ""}})
+	resp := execLocal([]string{root}, &runnerReq{ID: "0", Tool: "local_list_dir", Args: map[string]any{"path": ""}})
+	if !resp.OK || !strings.Contains(resp.Content, "authorized_dirs") {
+		t.Fatalf("空路径应返回授权目录清单: ok=%v content=%s", resp.OK, resp.Content)
+	}
+
+	// list_dir 指定目录
+	resp = execLocal([]string{root}, &runnerReq{ID: "1", Tool: "local_list_dir", Args: map[string]any{"path": root}})
 	if !resp.OK {
 		t.Fatalf("list_dir 失败: %s", resp.Error)
 	}
@@ -80,19 +86,19 @@ func TestExecLocalListAndRead(t *testing.T) {
 	}
 
 	// read_file 子目录文件
-	resp = execLocal(root, &runnerReq{ID: "2", Tool: "local_read_file", Args: map[string]any{"path": "sub/b.txt"}})
+	resp = execLocal([]string{root}, &runnerReq{ID: "2", Tool: "local_read_file", Args: map[string]any{"path": "sub/b.txt"}})
 	if !resp.OK || resp.Content != "world" {
 		t.Fatalf("read_file 失败: ok=%v content=%q err=%s", resp.OK, resp.Content, resp.Error)
 	}
 
 	// read_file 越界必须拒
-	resp = execLocal(root, &runnerReq{ID: "3", Tool: "local_read_file", Args: map[string]any{"path": "../outside.txt"}})
+	resp = execLocal([]string{root}, &runnerReq{ID: "3", Tool: "local_read_file", Args: map[string]any{"path": "/etc/passwd"}})
 	if resp.OK {
 		t.Fatal("越界读未被拦截")
 	}
 
 	// 未知工具（写/exec 都不在只读版里）必须拒
-	resp = execLocal(root, &runnerReq{ID: "4", Tool: "local_write_file", Args: map[string]any{"path": "a.txt"}})
+	resp = execLocal([]string{root}, &runnerReq{ID: "4", Tool: "local_write_file", Args: map[string]any{"path": "a.txt"}})
 	if resp.OK {
 		t.Fatal("未注册操作未被拦截")
 	}

sundynix-gateway/cmd/localsim/main.go

@@ -36,36 +36,45 @@ type resp struct {
 
 func main() {
 	gw := flag.String("gw", "ws://localhost:8080", "gateway WS 基址")
-	dir := flag.String("dir", ".", "沙箱工作目录")
+	dir := flag.String("dir", ".", "授权目录，逗号分隔（模拟桌面端的多目录白名单）")
 	flag.Parse()
 	token := os.Getenv("LOCALSIM_TOKEN")
 	if token == "" {
 		log.Fatal("缺 LOCALSIM_TOKEN（用户 JWT）")
 	}
-	root, err := filepath.Abs(*dir)
+	var roots []string
-	if err != nil {
+	for _, d := range strings.Split(*dir, ",") {
-		log.Fatal(err)
+		if d = strings.TrimSpace(d); d == "" {
+			continue
+		}
+		abs, err := filepath.Abs(d)
+		if err != nil {
+			log.Fatal(err)
+		}
+		roots = append(roots, abs)
+	}
+	if len(roots) == 0 {
+		log.Fatal("至少一个目录")
 	}
-
 	url := strings.TrimRight(*gw, "/") + "/api/v1/local/runner?token=" + token
 	// 断线自动重连（对齐真桌面端 runner 的 5s 退避）：网关重启时联调不用手动重拉。
 	for {
-		if err := serveOnce(url, root); err != nil {
+		if err := serveOnce(url, roots); err != nil {
 			log.Printf("连接断开（5s 后重连）: %v", err)
 		}
 		time.Sleep(5 * time.Second)
 	}
 }
 
-func serveOnce(url, root string) error {
+func serveOnce(url string, roots []string) error {
 	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
 	if err != nil {
 		return err
 	}
 	defer conn.Close()
-	log.Printf("已注册为本地执行器 workdir=%s", root)
+	log.Printf("已注册为本地执行器 授权目录=%s", strings.Join(roots, "、"))
 
-	hello, _ := json.Marshal(resp{ID: "hello", OK: true, Workdir: root})
+	hello, _ := json.Marshal(resp{ID: "hello", OK: true, Workdir: strings.Join(roots, "、")})
 	_ = conn.WriteMessage(websocket.TextMessage, hello)
 
 	for {
@@ -78,18 +87,40 @@ func serveOnce(url, root string) error {
 			continue
 		}
 		log.Printf("收到调用 tool=%s args=%v", r.Tool, r.Args)
-		out, _ := json.Marshal(handle(root, &r))
+		out, _ := json.Marshal(handle(roots, &r))
 		if err := conn.WriteMessage(websocket.TextMessage, out); err != nil {
 			return err
 		}
 	}
 }
 
-func handle(root string, r *req) *resp {
+func handle(roots []string, r *req) *resp {
+	root := roots[0]
 	rel, _ := r.Args["path"].(string)
-	p := filepath.Join(root, filepath.Clean("/"+rel)) // 简版沙箱（联调工具；正式沙箱在桌面端）
+	// 简版沙箱（联调工具；正式沙箱在桌面端 resolveAllowed）：绝对路径须落在某个授权根内。
+	p := rel
+	if p == "" {
+		p = root
+	} else if !filepath.IsAbs(p) {
+		p = filepath.Join(root, filepath.Clean("/"+p))
+	}
+	p = filepath.Clean(p)
+	inRoot := false
+	for _, rt := range roots {
+		if p == rt || strings.HasPrefix(p, rt+string(filepath.Separator)) {
+			inRoot = true
+			break
+		}
+	}
+	if !inRoot {
+		return &resp{ID: r.ID, OK: false, Error: "路径不在授权目录内: " + p}
+	}
 	switch r.Tool {
 	case "local_list_dir":
+		if strings.TrimSpace(rel) == "" {
+			data, _ := json.Marshal(map[string]any{"authorized_dirs": roots})
+			return &resp{ID: r.ID, OK: true, Content: string(data)}
+		}
 		ents, err := os.ReadDir(p)
 		if err != nil {
 			return &resp{ID: r.ID, OK: false, Error: err.Error()}

sundynix-gateway/internal/handler/platform_tools.go

@@ -73,28 +73,39 @@ func (h *Handler) platformRegistry() map[string]platTool {
 		// —— 本地的手（P4，只读起步）：执行发生在用户自己的桌面（沙箱工作目录内），服务端只路由。
 		// 桌面端不在线/没开本地访问时工具会明确报不可用——如实转告用户即可。
 		"local_list_dir": {
-			cn: "看本地目录", desc: "列出用户本地工作目录（或其子目录）里的文件。用户问“我这个目录/文件夹里有什么”时调用。仅用户桌面端在线且开启了本地访问才可用。",
+			cn: "看本地目录", desc: "列出用户电脑上某个目录里的文件。**path 留空会返回用户授权你访问的目录清单**——不知道该看哪时先这样调一次。用户问“我某个文件夹里有什么/桌面上有什么”时调用。仅用户桌面端在线且开启本地访问才可用。",
-			params: []platParam{{Name: "path", Type: "string", Desc: "相对工作目录的子路径，空=根目录"}},
+			params: []platParam{{Name: "path", Type: "string", Desc: "目录的绝对路径（如 /Users/xx/Desktop）；留空=返回授权目录清单"}},
 			inject: []string{"user_id"}, handler: h.platLocalExec,
 		},
 		"local_read_file": {
-			cn: "读本地文件", desc: "读取用户本地工作目录内某个文件的文本内容（大文件截断）。用户让“看看/读一下 某个本地文件”时调用。仅用户桌面端在线且开启了本地访问才可用。",
+			cn: "读本地文件", desc: "读取用户电脑上某个文件的文本内容（大文件截断）。用户让“看看/读一下 某个文件”时调用。仅用户桌面端在线且开启本地访问才可用。",
-			params: []platParam{{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true}},
+			params: []platParam{{Name: "path", Type: "string", Desc: "文件的绝对路径", Required: true}},
 			inject: []string{"user_id"}, handler: h.platLocalExec,
 		},
 		// —— 能动的手：写文件 / 执行命令。桌面端会弹原生确认框让用户逐次批准（默认拒绝），
 		// 且命中安全黑名单的命令直接拒绝。被拒时如实告诉用户，别重试绕路。
 		"local_write_file": {
-			cn: "写本地文件", desc: "在用户本地工作目录内写入/覆盖一个文本文件。用户明确要求“写个文件/保存到本地/生成脚本”时调用。用户会在桌面端收到确认框，需其批准才真正写入。",
+			cn: "写本地文件", desc: "在用户电脑上写入/覆盖一个文本文件（只能写进用户授权的目录）。用户要求“写个文件/保存到本地/生成脚本”时调用。用户会在桌面端收到确认框，需其批准才真正写入。",
 			params: []platParam{
-				{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true},
+				{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 秒）。用户要求“跑一下/执行/编译/查一下某个命令结果”时调用。用户会在桌面端收到确认框，需其批准才执行；删库、提权、写系统路径等危险命令会被直接拒绝。一次只提交一条命令，别猜着连环执行。",
+			cn: "操作电脑", desc: `在用户的 Mac 上执行一条 shell 命令并返回输出（超时 60 秒）。这是你操作这台电脑的主要手段，能干的远不止跑脚本：
-			params: []platParam{{Name: "command", Type: "string", Desc: "要执行的 shell 命令，如 ls -la、git status、npm test", Required: true}},
+- 文件整理：mv / cp / mkdir / 批量重命名（find + mv）
+- 找东西：mdfind "关键词"（Spotlight 全盘搜索）、grep -rn、ls
+- 开应用/开文件：open -a "Safari"、open /path/to/file、open https://...
+- 控制 App（AppleScript）：osascript -e 'tell application "Music" to play'、暂停播放、发邮件、建日历事件、取当前播放歌曲等
+- 触发快捷指令：shortcuts run "指令名"（用户在「快捷指令」App 里建的自动化，可含智能家居场景）；shortcuts list 可先列出有哪些
+- 系统信息：df -h、uptime、pmset -g batt（电量）
+用户说“打开某某/放首歌/把这些文件整理一下/找找那个文档在哪”都用这个工具。
+用户会在桌面端收到确认框，需其批准才执行；删库、提权、写系统路径等危险命令会被直接拒绝。一次只提交一条命令。`,
+			params: []platParam{
+				{Name: "command", Type: "string", Desc: "要执行的 shell 命令", Required: true},
+				{Name: "cwd", Type: "string", Desc: "在哪个授权目录里执行（绝对路径，可选；默认第一个授权目录）"},
+			},
 			inject: []string{"user_id"}, timeoutSec: 160, handler: h.platLocalExec,
 		},
 		// —— 调度：让用户能说「每天早上九点帮我看看昨天的任务」。到点由 JARVIS 自己按指令办事并播报。

sundynix-gateway/internal/handler/voice_task.go

@@ -25,9 +25,12 @@ func voiceSystemPrompt(name, persona string) string {
 	if n == "" {
 		n = defaultJarvisName
 	}
-	s := "你是 " + n + "——用户的私人语音助手，也是这套平台与他电脑的中枢。你能：查/派任务与报告、" +
+	s := "你是 " + n + "——用户的私人语音助手，也是他这台电脑的操作者。你能：" +
-		"切换客户端界面、在用户授权的工作目录里看文件读文件、写文件、执行 shell 命令、" +
+		"在用户授权的目录里看/读/写文件、执行 shell 命令（据此可以整理文件、用 mdfind 全盘找东西、" +
-		"以及建定时任务（到点自动办事并播报）。相应工具会提供给你，需要就调。" +
+		"open 打开应用和文件、osascript 控制 Mac 上的 App、shortcuts run 触发快捷指令）、" +
+		"查/派平台任务与报告、切换客户端界面、建定时任务（到点自动办事并播报）。" +
+		"用户让你「做点什么」时，先想清楚用哪个工具、一步步做，别只是嘴上答应。" +
+		"不知道能访问哪些目录，就用 local_list_dir 留空 path 查一次。" +
 		"铁律一：凡是用户问任务/报告的状态、进度、结果，**必须先调工具查真实数据再回答**——" +
 		"哪怕你觉得自己记得，也不许凭记忆或上下文编造任务状态；查不到就如实说查不到。" +
 		"铁律二：涉及写文件/执行命令，用户会在电脑上收到确认框；被拒绝或被安全策略挡下时如实告诉他，" +