cj-tauri 0.8.0 → 1.1.0

package/src/{plugin_dialog.cj → plugins/dialog/plugin_dialog.cj}

@@ -1,4 +1,6 @@
-package cjTauri
+package cjTauri.plugins.dialog
+
+import cjTauri.*
 
 import std.collection.*
 import stdx.encoding.json.*
@@ -6,18 +8,19 @@ import stdx.encoding.json.*
 /**
  * 官方插件 dialog：原生对话框（对标 Tauri 的 dialog 插件）
  *
- * 命令：dialog:open / dialog:save / dialog:message
+ * 命令：dialog:open / dialog:save / dialog:pickFolder / dialog:message
  * 权限：**不自动放行**，应用要在 capabilities 里显式声明，两种写法等价：
  *   "commands": ["dialog:open", "dialog:message"]     // 明文逐条
  *   "permissions": ["dialog:default"]                 // 命名权限集（v1.1，一次放行一组）
  * 前端：window.__CJ_TAURI__.dialog.open({ filter: "文本文件|*.txt|所有文件|*.*" })
+ *       window.__CJ_TAURI__.dialog.pickFolder({ title: "选择目录" })  // 选目录（返回选中目录的绝对路径）
  *
  * 与 fs 插件的差别：这里要落到**系统对话框**，所以弹窗归宿主层（Windows 走 Win32 通用对话框、
  * Linux 走 GTK），插件只做参数校验与命令分发——平台差异不进插件，与 AGENTS.md §2 的架构契约一致。
  * 对话框需要父窗口，故必须等应用启动（start 之后）再调用；更早调用得到的是空结果（取消）。
  */
 public class DialogPlugin <: Plugin {
-    // 三个命令共用一个处理器实例：setup() 里把宿主交给它（装配必须在 run()/runUrl() 之前完成）
+    // 四个命令共用一个处理器实例：setup() 里把宿主交给它（装配必须在 run()/runUrl() 之前完成）
     private let handler: DialogCommands = DialogCommands()
 
     public init() {}
@@ -30,23 +33,27 @@ public class DialogPlugin <: Plugin {
         let m = HashMap<String, CommandHandler>()
         m.add("open", this.handler)
         m.add("save", this.handler)
+        m.add("pickFolder", this.handler)
         m.add("message", this.handler)
         return m
     }
 
     /**
-     * 命名权限集（v1.1）：files 只放行两个文件选择命令，message（模态提示框）不在其中。
-     * 只想让用户挑个文件的应用引用 files 即可，不必顺带拿到「能弹任意提示框」的能力。
+     * 命名权限集（v1.1）：files 放行三个「挑路径」命令（open / save / pickFolder），
+     * message（模态提示框）不在其中。只想让用户挑个文件或目录的应用引用 files 即可，
+     * 不必顺带拿到「能弹任意提示框」的能力。
      */
     public func permissions(): HashMap<String, ArrayList<String>> {
         let m = HashMap<String, ArrayList<String>>()
         let files = ArrayList<String>()
         files.add("open")
         files.add("save")
+        files.add("pickFolder")
         m.add("files", files)
         let all = ArrayList<String>()
         all.add("open")
         all.add("save")
+        all.add("pickFolder")
         all.add("message")
         m.add("default", all)
         return m
@@ -60,6 +67,7 @@ public class DialogPlugin <: Plugin {
             " t.dialog = {" +
             " open: function (args) { return window.__CJ_TAURI__.invoke('dialog:open', args); }," +
             " save: function (args) { return window.__CJ_TAURI__.invoke('dialog:save', args); }," +
+            " pickFolder: function (args) { return window.__CJ_TAURI__.invoke('dialog:pickFolder', args); }," +
             " message: function (args) { return window.__CJ_TAURI__.invoke('dialog:message', args); }" +
             " }; })();\n"
     }
@@ -67,37 +75,77 @@ public class DialogPlugin <: Plugin {
     /**
      * 装配宿主：命令要靠它弹原生对话框。
      * 这里只是把宿主对象记下来（宿主在构造 TauriApp 时就存在），真正弹窗要等 start 之后。
+     *
+     * **两个槽都装**：`app.webviewHost()` 只是默认窗那一个，多窗口下拿它等于
+     * 「谁先装配谁收所有弹窗」（第二扇窗的框排进默认窗队列，实测见 docs/鸿蒙ArkWeb接入踩坑.md §10.12）；
+     * `app.hostOf` 才是按报文里的窗口取正确宿主的那条路，命令执行时用。
      */
     public func setup(app: TauriApp): Unit {
         this.handler.attachHost(app.webviewHost())
+        this.handler.attachHostResolver({ label => app.hostOf(label) })
     }
 }
 
 /**
  * dialog 插件的命令处理器（三个命令共用一份，按全名分派，与内置 SystemCommands 同形）
  */
-class DialogCommands <: CommandHandler {
+// public 是给单测用的（跨包要能直接构造命令处理器，见 AGENTS §2「单测要直接构造的命令 handler 须 public」）
+public class DialogCommands <: CommandHandler {
     // 宿主层（弹原生对话框）；未经 DialogPlugin 装配时为 None，命令给出可读的错误而不是崩
     private var host: Option<WebViewHost> = None
 
+    /* 按 label 解析宿主（多窗口的正路）：单槽 `host` 只记着**装配时那一个**宿主，
+       多窗口下用它就是「谁先装配谁收所有弹窗」——2026-10-20 鸿蒙真机实测：两扇窗同时弹框，
+       hilog 两次 `dialog take label=main`，第二次的 title 却是 second，且 main 的 @State
+       被覆盖成对面内容、第二窗自己的框从未显示（判据与过程见 docs/鸿蒙ArkWeb接入踩坑.md §10.12）。
+       单测也靠它注入桩宿主，不必构造真实 TauriApp。 */
+    private var hostByWindow: Option<(String) -> Option<WebViewHost>> = None
+
     public init() {}
 
-    /** 由 DialogPlugin.setup() 调用 */
-    func attachHost(h: WebViewHost): Unit {
+    /**
+     * 装配**单个**宿主（单窗口 / 单测用）
+     *
+     * 多窗口一律走 `attachHostResolver`：这个槽不带窗口身份，第二扇窗的命令会落到这里那一个宿主上。
+     * 两者同时装时可以共存——解析器优先，`host` 退成兜底（解析器给出 None 时才用）。
+     */
+    public func attachHost(h: WebViewHost): Unit {
         this.host = Some(h)
     }
 
+    /** 装配「label → 宿主」解析器；由 DialogPlugin.setup() 传入 `app.hostOf` */
+    public func attachHostResolver(resolve: (String) -> Option<WebViewHost>): Unit {
+        this.hostByWindow = Some(resolve)
+    }
+
     public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
-        let _ = ipc
         match (cmd) {
-            case "dialog:open" => JsonString(this.pickFile(args, false))
-            case "dialog:save" => JsonString(this.pickFile(args, true))
-            case "dialog:message" => JsonBool(this.message(args))
+            case "dialog:open" => JsonString(this.pickFile(args, false, ipc))
+            case "dialog:save" => JsonString(this.pickFile(args, true, ipc))
+            case "dialog:pickFolder" => JsonString(this.pickFolder(args, ipc))
+            case "dialog:message" => JsonBool(this.message(args, ipc))
             case _ => throw CommandException("unknown dialog command: ${cmd}")
         }
     }
 
-    private func requireHost(): WebViewHost {
+    /**
+     * 取**发起这条命令的窗口**的宿主
+     *
+     * 多窗口下必须按 `ipc.window` 解析：用装配时那一个宿主，第二扇窗的弹窗会排进默认窗的队列，
+     * 表象是「另一扇窗里冒出别人的框」外加「自己那个框永远不出现」。
+     * 解析器在场而窗口没登记时**如实报错**，不要悄悄回落到单槽——那正是串台的来源。
+     */
+    private func requireHost(ipc: IpcContext): WebViewHost {
+        match (this.hostByWindow) {
+            case Some(resolve) => match (resolve(ipc.window)) {
+                case Some(h) => return h
+                // 解析器在场＝多窗口正路：这里回落到单槽就是「弹到别人窗口里」，
+                // 所以宁可不弹，把窗口 label 原样报出去（少一个框好过串台）。
+                case None => throw CommandException(
+                    "dialog: 窗口 \"${ipc.window}\" 没有登记宿主（addWindow(); 默认窗在 run() 之前也可用）")
+            }
+            case None => ()
+        }
         match (this.host) {
             case Some(h) => h
             case None => throw CommandException(
@@ -127,7 +175,7 @@ class DialogCommands <: CommandHandler {
         }
     }
 
-    private func pickFile(args: JsonObject, save: Bool): String {
+    private func pickFile(args: JsonObject, save: Bool, ipc: IpcContext): String {
         var title = this.optionalString(args, "title", "")
         if (title.size == 0) {
             if (save) {
@@ -137,16 +185,25 @@ class DialogCommands <: CommandHandler {
             }
         }
         let filter = this.optionalString(args, "filter", "")
-        return this.requireHost().showFileDialog(save, title, filter)
+        return this.requireHost(ipc).showFileDialog(save, title, filter)
+    }
+
+    /** 选目录（宿主侧 kind=6）：只有 title 一个可选参数；取消回空串，与文件框同语义 */
+    private func pickFolder(args: JsonObject, ipc: IpcContext): String {
+        var title = this.optionalString(args, "title", "")
+        if (title.size == 0) {
+            title = "选择文件夹"
+        }
+        return this.requireHost(ipc).showFolderDialog(title)
     }
 
-    private func message(args: JsonObject): Bool {
+    private func message(args: JsonObject, ipc: IpcContext): Bool {
         let text = this.requireString(args, "message")
         let kind = this.optionalString(args, "kind", "info")
         var title = this.optionalString(args, "title", "")
         if (title.size == 0) {
             title = "提示"
         }
-        return this.requireHost().showMessageDialog(kind, title, text)
+        return this.requireHost(ipc).showMessageDialog(kind, title, text)
     }
 }

package/src/plugins/fs/plugin_fs.cj

@@ -0,0 +1,194 @@
+package cjTauri.plugins.fs
+
+import cjTauri.*
+
+import std.collection.*
+import std.fs.*
+import stdx.encoding.json.*
+
+/**
+ * 官方插件 fs：文件读写（纯仓颉，零 C 桥改动，RFC-001 §7.3）
+ *
+ * 命令：fs:readText / fs:writeText / fs:exists / fs:list / fs:remove
+ *   - readText / writeText：整文件读写（writeText 是覆盖写：已存在会截断，不存在则创建）
+ *   - exists：路径是否存在
+ *   - list：**平铺一层**列目录，返回 [{ name, dir, size }]；不递归，顺序就是文件系统给的顺序（展示排序交给前端）
+ *   - remove：只删**单个文件**，目标是目录一律拒——std.fs 的 remove 能把**空目录**也删掉，
+ *     所以这层挡在调用前（不做递归删除）；文件不存在同样报错：调用方本想删的东西没删掉，
+ *     静默回 true 等于把失败伪装成成功
+ * 权限：**不自动放行**，应用要在 capabilities 里显式声明，两种写法等价：
+ *   "commands": ["fs:readText", "fs:exists"]        // 明文逐条（旧写法，一直支持）
+ *   "permissions": ["fs:readonly"]                  // 命名权限集（v1.1，一次放行一组）
+ * 路径：`scopeAware()` 为真——页面给的 path 一律经 IpcContext.resolveScopedPath 校验；
+ *   清单里写了 "scopes": { "fs": { "allow": [...], "deny": [...] } } 就按白名单判定（越界即拒），
+ *   没写就维持旧行为（全量放行，启动时打一行 stderr 提示）。见 docs/RFC-插件路线图.md 第 4 期。
+ * 前端：window.__CJ_TAURI__.fs.readText({ path: "notes.txt" })
+ */
+public class FsPlugin <: Plugin {
+    public init() {}
+
+    public func name(): String {
+        return "fs"
+    }
+
+    /** 本插件的路径参数吃 scope 校验（RFC-003 第 4 期）：唯一带任意路径的官方插件 */
+    public func scopeAware(): Bool {
+        return true
+    }
+
+    public func commands(): HashMap<String, CommandHandler> {
+        let m = HashMap<String, CommandHandler>()
+        m.add("readText", FsCommands())
+        m.add("writeText", FsCommands())
+        m.add("exists", FsCommands())
+        m.add("list", FsCommands())
+        m.add("remove", FsCommands())
+        return m
+    }
+
+    /**
+     * 命名权限集（v1.1，对标 Tauri v2 的 fs:default / fs:allow-read-text-file）。
+     *
+     * readonly 只含读相关两条：只想读文件的应用引用它即可，**写能力不会被顺带打开**；
+     * 要写文件必须显式引用 default（或把 fs:writeText 写成明文）——最小权限不打折。
+     * 集内写短名（readText），框架自动补成 fs:readText。
+     */
+    public func permissions(): HashMap<String, ArrayList<String>> {
+        let m = HashMap<String, ArrayList<String>>()
+        let ro = ArrayList<String>()
+        ro.add("readText")
+        ro.add("exists")
+        ro.add("list")      // 列目录也是读操作：只读应用（如文件浏览）要能拿它，但拿不到 remove
+        m.add("readonly", ro)
+        let all = ArrayList<String>()
+        all.add("readText")
+        all.add("writeText")
+        all.add("exists")
+        all.add("list")
+        all.add("remove")
+        m.add("default", all)
+        return m
+    }
+
+    /**
+     * 前端 shim：往桥对象上挂一个 fs 命名空间。
+     * 只动 __CJ_TAURI__ 的一个命名空间，不碰 invoke / listen / emit，也不注册全局变量。
+     */
+    public func jsShim(): String {
+        return "(function () { var t = window.__CJ_TAURI__ || (window.__CJ_TAURI__ = {});" +
+            " t.fs = {" +
+            " readText: function (args) { return window.__CJ_TAURI__.invoke('fs:readText', args); }," +
+            " writeText: function (args) { return window.__CJ_TAURI__.invoke('fs:writeText', args); }," +
+            " exists: function (args) { return window.__CJ_TAURI__.invoke('fs:exists', args); }," +
+            " list: function (args) { return window.__CJ_TAURI__.invoke('fs:list', args); }," +
+            " remove: function (args) { return window.__CJ_TAURI__.invoke('fs:remove', args); }" +
+            " }; })();\n"
+    }
+}
+
+/**
+ * fs 插件的命令处理器（三个命令共用一份，按全名分派，与内置 SystemCommands 同形）
+ */
+class FsCommands <: CommandHandler {
+    public init() {}
+
+    public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
+        match (cmd) {
+            case "fs:readText" => this.readText(args, ipc)
+            case "fs:writeText" => this.writeText(args, ipc)
+            case "fs:exists" => this.exists(args, ipc)
+            case "fs:list" => this.listEntries(args, ipc)
+            case "fs:remove" => this.removeFile(args, ipc)
+            case _ => throw CommandException("unknown fs command: ${cmd}")
+        }
+    }
+
+    /**
+     * 取路径参数并过 scope 校验：越界在**这里**就抛（前端拿到可读错误），
+     * 命令体拿到的一定是已经规范化、且落在白名单里的路径。
+     */
+    private func scopedPath(args: JsonObject, ipc: IpcContext): String {
+        return ipc.resolveScopedPath("fs", this.requireString(args, "path"))
+    }
+
+    /** 取必需的字符串参数；缺失或类型不对时抛业务错误，前端拿到的是可读原文 */
+    private func requireString(args: JsonObject, key: String): String {
+        match (args.get(key)) {
+            case Some(v) => match (v.kind()) {
+                case JsonKind.JsString => return v.asString().getValue()
+                case _ => throw CommandException("fs: argument \"${key}\" must be a string")
+            }
+            case None => throw CommandException("fs: missing argument \"${key}\"")
+        }
+    }
+
+    private func readText(args: JsonObject, ipc: IpcContext): JsonValue {
+        let path = this.scopedPath(args, ipc)
+        try {
+            return JsonString(String.fromUtf8(File.readFrom(path)))
+        } catch (e: Exception) {
+            throw CommandException("fs:readText failed: ${e}")
+        }
+    }
+
+    private func writeText(args: JsonObject, ipc: IpcContext): JsonValue {
+        let path = this.scopedPath(args, ipc)
+        let contents = this.requireString(args, "contents")
+        try {
+            // File.writeTo 是覆盖写：文件已存在会截断，不存在则创建——不需要先删（与 File.create 不同）
+            File.writeTo(path, contents.toArray())
+            return JsonBool(true)
+        } catch (e: Exception) {
+            throw CommandException("fs:writeText failed: ${e}")
+        }
+    }
+
+    private func exists(args: JsonObject, ipc: IpcContext): JsonValue {
+        let path = this.scopedPath(args, ipc)
+        return JsonBool(exists(path))
+    }
+
+    /**
+     * 列目录：**平铺一层**、不递归——递归遍历是应用层的事，插件契约越薄越不容易被绕过。
+     * name 直接取 FileInfo.name（等价于 path.fileName），目录项也照报（dir=true），显不显示由页面定。
+     * 顺序不做保证：仓颉侧不排序（`ArrayList.sort` 已废弃），要稳定顺序在前端排。
+     */
+    private func listEntries(args: JsonObject, ipc: IpcContext): JsonValue {
+        let path = this.scopedPath(args, ipc)
+        var entries: Array<FileInfo>
+        try {
+            entries = Directory.readFrom(path)
+        } catch (e: Exception) {
+            throw CommandException("fs:list failed: ${e}")
+        }
+        let items = ArrayList<JsonValue>()
+        for (info in entries) {
+            let obj = JsonObject()
+            obj.put("name", JsonString(info.name))
+            obj.put("dir", JsonBool(info.isDirectory()))
+            obj.put("size", JsonInt(info.size))
+            items.add(obj)
+        }
+        return JsonArray(items)
+    }
+
+    /**
+     * 删单个文件。判定顺序不能反：**先确认存在、再挡住目录、最后才 remove**。
+     * 漏掉中间那步，一个空目录会被 std.fs 的 remove 静默删掉（它同时管文件和目录）。
+     */
+    private func removeFile(args: JsonObject, ipc: IpcContext): JsonValue {
+        let path = this.scopedPath(args, ipc)
+        if (!exists(path)) {
+            throw CommandException("fs:remove failed: no such file: ${path}")
+        }
+        if (FileInfo(path).isDirectory()) {
+            throw CommandException("fs:remove refused: is a directory: ${path}")
+        }
+        try {
+            remove(path)
+            return JsonBool(true)
+        } catch (e: Exception) {
+            throw CommandException("fs:remove failed: ${e}")
+        }
+    }
+}