cj-tauri 0.8.0 → 1.1.0

package/src/capability.cj

@@ -1,6 +1,7 @@
 package cjTauri
 
 import std.collection.*
+import std.sync.*
 import stdx.encoding.json.*
 
 /**
@@ -29,6 +30,12 @@ public class Capability {
     public let events: HashSet<String>
     /** 引用到的命名权限集（原始名，如 "fs:readonly"）；展开规则见 CapabilityRegistry */
     public let permissions: HashSet<String>
+    /**
+     * 路径 scope（RFC-003 第 4 期）：插件名 → 路径白名单规则。
+     * 没有某插件的条目 = 该插件按旧行为全量放行（启动时有 stderr 提示）；
+     * 有条目就走「先 deny 后 allow」的二次校验，见 src/scope.cj。
+     */
+    public let scopes: HashMap<String, ScopeRule>
 
     public init(identifier: String) {
         this.identifier = identifier
@@ -36,6 +43,7 @@ public class Capability {
         this.commands = HashSet<String>()
         this.events = HashSet<String>()
         this.permissions = HashSet<String>()
+        this.scopes = HashMap<String, ScopeRule>()
     }
 
     public func allowCommand(cmd: String): Unit {
@@ -147,6 +155,20 @@ public class Capability {
                     case _ => ()
                 }
             }
+            // scopes：插件名 → 路径白名单（RFC-003 第 4 期）。键不认识也照收——
+            // 判定只在「插件真的来问」时发生，写错的键不会放行任何东西，只会让本该严的规则不生效
+            if (let Some(scopes) <- obj.get("scopes")) {
+                match (scopes.kind()) {
+                    case JsonKind.JsObject =>
+                        // JsonObject 没有 keys()，取 fields 这张表来遍历（plugin_store.cj 同样写法）
+                        for ((k, v) in scopes.asObject().getFields()) {
+                            if (let Some(rule) <- parseScopeRule(v)) {
+                                cap.scopes.add(k, rule)
+                            }
+                        }
+                    case _ => ()
+                }
+            }
             return Some(cap)
         } catch (e: Exception) {
             return None
@@ -161,6 +183,12 @@ public class CapabilityRegistry {
     private var caps: ArrayList<Capability> = ArrayList<Capability>()
     // 命名权限集：集名（"fs:readonly"）→ 成员全名。由插件装配时注册（plugin.cj 的 registerPluginPermissionSets）
     private var permissionSets: HashMap<String, HashSet<String>> = HashMap<String, HashSet<String>>()
+    // 运行期叠加的 scope 白名单（插件名 → 模式）：由应用**取得用户明确确认后**经
+    // TauriApp.allowScopePattern 追加（如原生确认框问到「是」）。只在内存里，重启即失效——
+    // 持久化是应用自己的事（决定权在应用：写哪、写不写）。命令分发是异步的（worker 线程读
+    // scope），所以叠加与读取共用同一把锁。
+    private var runtimeScopeAllow: HashMap<String, ArrayList<String>> = HashMap<String, ArrayList<String>>()
+    private let scopeLock: Mutex = Mutex()
 
     public init() {}
 
@@ -249,6 +277,118 @@ public class CapabilityRegistry {
         return this.coveredByPermissionSet(event)
     }
 
+    /**
+     * 某个插件的路径 scope（RFC-003 第 4 期）：把所有清单里给它的规则**并集**起来。
+     * 返回 None = 没有任何清单为它写 scope → 调用方按旧行为全量放行。
+     *
+     * 为什么是并集而不是「逐清单分别判定」：与 canInvoke / canEmit 的口径一致——
+     * 现有能力模型就是「任一清单放行即放行」，scope 跟着同一条口径走才解释得清。
+     * （列级 + 窗口级 scopes 是 Tauri v2 更细的模型，本轮不做，见 RFC-003 第 4 期。）
+     */
+    public func scopeForPlugin(plugin: String): Option<ScopeRule> {
+        var found = false
+        let merged = ScopeRule()
+        for (c in this.caps) {
+            match (c.scopes.get(plugin)) {
+                case Some(rule) =>
+                    found = true
+                    for (a in rule.allow) {
+                        merged.allow.add(a)
+                    }
+                    for (d in rule.deny) {
+                        merged.deny.add(d)
+                    }
+                case None => ()
+            }
+        }
+        if (!found) {
+            return None
+        }
+        // 运行期叠加的白名单与清单成员同权（放在这里，是为了守住「注册中心是唯一判定口径」——
+        // 各插件的 scope 判定全都经 scopeForPlugin，不必各自再查一遍运行期表）。
+        this.mergeRuntimeAllow(plugin, merged)
+        return Some(merged)
+    }
+
+    /**
+     * 运行期给某插件的 scope 追加一条 allow 模式（插件名如 "http"，模式写法同 `scope.cj`）。
+     *
+     * 用途：应用**取得用户明确确认后**（如弹原生确认框）放行一个清单里没有的主机，让本次会话当场可用。
+     * 判定顺序不变：**清单里的 deny 命中即拒，运行期加白掀不掉它**。
+     *
+     * **只收「具体值」，不收通配**：模式里出现 `*` 或 `?` 一律拒绝（返回 false + 一行 stderr）。
+     * 加白的语义是「往已有白名单里加一条」，而模式是页面可控字符串——一个通配透传进来就等价于全放行，
+     * 整条防线当场作废。这条不变量放在注册中心里强制，任何应用都绕不过去（D-021 的代价第 1 条）。
+     */
+    public func addRuntimeScopeAllow(plugin: String, pattern: String): Bool {
+        if (!isConcreteScopeValue(pattern)) {
+            eprintln("[cj-tauri] runtime scope allow refused (${plugin}): pattern must be a concrete value, got '${pattern}'")
+            return false
+        }
+        synchronized(this.scopeLock) {
+            if (!this.runtimeScopeAllow.contains(plugin)) {
+                this.runtimeScopeAllow.add(plugin, ArrayList<String>())
+            }
+            let list = this.runtimeScopeAllow.get(plugin).getOrThrow()
+            if (!list.contains(pattern)) {
+                list.add(pattern)
+            }
+        }
+        return true
+    }
+
+    /**
+     * 运行期加白只收「不含通配的具体值」：`*` / `?` 会让模式退化成「全放行」，制表 / 换行 / 回车
+     * 则几乎总是「从文件或页面读回来时带了脏字符」，两类都拒（口径见 `addRuntimeScopeAllow`）。
+     * 注意 `String` 迭代出来的是 UTF-8 **字节**而不是码点，这里判的正是字节字面量。
+     */
+    private func isConcreteScopeValue(pattern: String): Bool {
+        if (pattern.size == 0) {
+            return false
+        }
+        for (b in pattern) {
+            if (b == 42u8 || b == 63u8 || b == 9u8 || b == 10u8 || b == 13u8) {
+                return false
+            }
+        }
+        return true
+    }
+
+    /** 某插件的 scope 此刻是否放行某个值（清单 + 运行期叠加；没写 scope 的插件恒放行＝旧行为） */
+    public func scopeAllowsValue(plugin: String, value: String): Bool {
+        match (this.scopeForPlugin(plugin)) {
+            case Some(rule) => return scopeAllows(rule, value)
+            case None => return true
+        }
+    }
+
+    /**
+     * 把运行期叠加项并进合并结果。**只有清单已为该插件写过 scope 时才并**：
+     * 没写 scope 的插件本来是全量放行（scopeForPlugin 返 None，调用方走旧行为），
+     * 这时把运行期条目并进去会把它意外收窄成「只放行这一条」。
+     */
+    private func mergeRuntimeAllow(plugin: String, merged: ScopeRule): Unit {
+        synchronized(this.scopeLock) {
+            match (this.runtimeScopeAllow.get(plugin)) {
+                case Some(extra) =>
+                    for (a in extra) {
+                        merged.allow.add(a)
+                    }
+                case None => ()
+            }
+        }
+    }
+
+    /** 是否有任何清单为某插件声明过 scope（启动提示与判定分支共用这一个口径） */
+    public func hasScopeForPlugin(plugin: String): Bool {
+        for (c in this.caps) {
+            if (c.scopes.contains(plugin)) {
+                return true
+            }
+        }
+        return false
+    }
+
     public func size(): Int64 {
         return this.caps.size
     }

package/src/clipboard_bridge.cj

@@ -0,0 +1,55 @@
+package cjTauri
+
+
+/**
+ * 剪贴板 / 通知桥（plugin_clipboard、plugin_notification 的 FFI 面）：
+ * C 桥 `cj_bridge_clipboard_*` / `cj_bridge_notification_*` 的声明与薄包装。
+ *
+ * 桌面两平台导出同名同签名（AGENTS §2 的硬约束），平台差异全在
+ * `native/bridge_*.c` 里——Linux 是 GTK clipboard + GDBus，Windows 是 Win32 clipboard +
+ * 通知桩（返回 -4 未实现）。所以仓颉侧一份声明就能同时编两个平台，上层不需要平台分支。
+ *
+ * 这组导出**收宿主句柄**：剪贴板与通知是宿主能力（GTK 环境依赖 / UI 线程投递），
+ * 与对话框同一类——必须等宿主就绪，句柄由 WebViewHost 持有。
+ *
+ * ## 鸿蒙侧为什么整段门禁掉（2026-10-19）
+ *
+ * 鸿蒙没有 C 桥产物（`native/platforms/harmonyos/` 目前只有契约），这四个符号无处解析。
+ * 留着的风险不是「编译报错」而是**模块加载期 SIGSEGV**——与 `log_bridge.cj` 那次
+ * 白屏三轮同源（AGENTS §4 最后一条：不带 `@When` 的核心 `foreign func` 在无桥平台
+ * 会留成未解析符号，`llvm-nm -D --undefined-only` 能一眼看出）。
+ *
+ * 门禁后鸿蒙侧**没有**这组导出，插件要剪贴板能力得走 `WebViewHost.clipboardWriteText` /
+ * `clipboardReadText`（`ArkWebHost` 目前如实返回 false / None，等 pasteboard 模块接上）；
+ * 谁在这儿补回同名导出，就等于把「宿主能力位 = 0」这条如实约定破坏掉。
+ */
+
+/**
+ * 写文本进系统剪贴板（8 MiB 上限在 C 侧 core 校验）。0 = 成功；-1 参数非法，-3 宿主未就绪 / 平台失败。
+ */
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_clipboard_write_text(h: CPointer<Unit>, text: CString): Int32
+
+/**
+ * 读系统剪贴板文本：返回 malloc 的 UTF-8 字符串（NULL = 剪贴板为空 / 非文本 / 平台失败）。
+ * 返回值必须经 `cj_bridge_clipboard_free` 释放——**不许**在仓颉侧 free（跨 CRT 堆不安全）。
+ */
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_clipboard_read_text(h: CPointer<Unit>): CString
+
+/**
+ * 释放 read_text 返回的缓冲（NULL 安全，幂等）
+ */
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_clipboard_free(s: CString): Unit
+
+/**
+ * 发一条系统通知（发后即忘：投递即返回，显示成败不回传）。
+ * 0 = 已提交；-1 参数非法（title 空 / 超长），-3 宿主未就绪 / 平台失败，-4 本平台未实现。
+ */
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_notification_notify(h: CPointer<Unit>, title: CString, body: CString): Int32

package/src/dragdrop.cj

@@ -0,0 +1,26 @@
+package cjTauri
+
+/**
+ * 拖放策略（RFC-002 §5 的 v1 落地）：框架只负责「把拖进来的文件路径交出去」，
+ * 动作由页面决定（监听 `dragdrop:files` 事件，事件需在能力清单 events 里声明）。
+ *
+ * 策略必须在 `start()` / `startUrl()` 之前通过 `TauriApp.setDragDrop(...)` 定稿——
+ * Linux 侧要在建 view 时决定挂不挂 drag dest；不设置 = 不注册（默认关，现有应用零改动）。
+ */
+public class DragDropPolicy {
+    /** 关掉则平台层不注册 drop target（默认关） */
+    public let enabled: Bool
+
+    /** 接受文件路径（v1 唯一载荷；text 载荷留给后续版本，先不设开关） */
+    public let files: Bool
+
+    public init(enabled: Bool, files: Bool) {
+        this.enabled = enabled
+        this.files = files
+    }
+
+    /** 便捷构造：开文件拖入（v1 最常用形态） */
+    public static func filesEnabled(): DragDropPolicy {
+        return DragDropPolicy(true, true)
+    }
+}

package/src/embedded_assets.cj

@@ -0,0 +1,98 @@
+package cjTauri
+
+/**
+ * 内嵌资源释放（单文件包专用）。
+ *
+ * 背景：应用产物可以打成**单个 exe**（`scripts/pack-win-single.sh`），页面 / 能力清单 / vendor JS
+ * 都编成字符串，但**随包的外部程序**（例如 cjnote 的 cjh 后端）没法静态链接进 exe，只能作为 PE
+ * 资源（RT_RCDATA）跟着走；运行期由本函数取出写盘，应用再按得到的路径去起它。
+ *
+ * `dir` 由调用方给（框架不认识应用名），典型是 `%LOCALAPPDATA%\<应用名>\runtime`；
+ * **调用方负责先把目录建好**（桥只建最后一级）。
+ *
+ * 返回值：> 0 = 就绪的文件数（本次释放的 + 本来就在的）；0 = 这个产物里没有内嵌资源
+ * （普通构建就是这样，**不是错误**）；-1 = 参数为空或写盘失败（原因在 stderr）。
+ * 幂等：目标已在且大小与资源一致时桥会跳过，所以每次启动都可以调。
+ */
+public func extractEmbeddedAssets(dir: String): Int64 {
+    if (dir.isEmpty()) {
+        eprintln("[cj-tauri] extractEmbeddedAssets: 目录为空")
+        return -1
+    }
+    let n = extractAssetsBridge(dir)
+    if (n < 0) {
+        eprintln("[cj-tauri] 释放内嵌资源失败：${dir}")
+    }
+    return n
+}
+
+/**
+ * 鸿蒙侧没有 C 桥产物（`native/platforms/harmonyos/` 目前只有契约），照桌面那份写声明会让模块
+ * 加载期就 SIGSEGV（与 `log_bridge.cj` / `process_hidden.cj` 同一条坑，AGENTS §4）——按 `env` 分叉，
+ * 如实降级。判据用 `env` 而不是 `arch`：桌面 aarch64 Linux 也有 C 桥。
+ */
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_extract_assets(dir: CString): Int32
+
+@When[env != "ohos"]
+func extractAssetsBridge(dir: String): Int64 {
+    var n: Int32 = 0
+    unsafe {
+        n = cj_bridge_extract_assets(LibC.mallocCString(dir))
+    }
+    return Int64(n)
+}
+
+@When[env == "ohos"]
+func extractAssetsBridge(dir: String): Int64 {
+    let _ = dir
+    eprintln("[cj-tauri] 本平台没有 C 桥，无内嵌资源可释放")
+    return 0
+}
+
+/**
+ * 按**绝对路径**预加载一个随包释放出来的动态库（单文件包专用）。
+ *
+ * 为什么需要它（2026-10-21 实测，另一台机器）：仓颉运行时的随机数默认实现走 OpenSSL，而它按
+ * **裸名**找 `libcrypto-3-x64.dll` / `libssl-3-x64.dll`——SDK 与 stdx 都不带这两个，开发机上只是
+ * 恰好命中 PATH 里 Git 自带的那份。于是同一条 `ws://` 连接线，本机全通、别人双击就挂：
+ * `ws: connect failed: Can not load openssl library or function RAND_bytes.`
+ * （RFC6455 升级要算 `Sec-WebSocket-Key` 的随机 nonce，**明文 ws 也逃不掉**）。
+ *
+ * 只要进程内先按绝对路径加载一次，之后同类裸名加载就命中已加载模块：不必改 PATH，
+ * 也不必把 DLL 摆到 exe 旁边（单文件承诺不破）。
+ *
+ * `path` 必须是释放后的真实路径；返回 true = 已在进程内（含本来就在的）。
+ * 平台没有 C 桥时如实返回 false（`src/log_bridge.cj` 同款门禁）。
+ */
+public func preloadEmbeddedLibrary(path: String): Bool {
+    if (path.isEmpty()) {
+        eprintln("[cj-tauri] preloadEmbeddedLibrary: 路径为空")
+        return false
+    }
+    let ok = preloadLibraryBridge(path)
+    if (!ok) {
+        eprintln("[cj-tauri] 预加载动态库失败：${path}")
+    }
+    return ok
+}
+
+@When[env != "ohos"]
+@C
+foreign func cj_bridge_preload_library(path: CString): Int32
+
+@When[env != "ohos"]
+func preloadLibraryBridge(path: String): Bool {
+    var ok: Int32 = 0
+    unsafe {
+        ok = cj_bridge_preload_library(LibC.mallocCString(path))
+    }
+    return ok == 1
+}
+
+@When[env == "ohos"]
+func preloadLibraryBridge(path: String): Bool {
+    let _ = path
+    return false
+}

package/src/hexutil.cj

@@ -0,0 +1,53 @@
+package cjTauri
+
+// 共享的 hex 工具：serial / mqtt / redis 三个插件都要做「字节 ↔ 十六进制」换算，
+// 放核心共享层（与 scope.cj 同判据：判定逻辑只在共享层，避免插件间互相引用导致连坐链接）。
+
+let HEX_DIGITS: String = "0123456789abcdef"
+
+/** 字节 → 小写十六进制（二进制帧给前端看的就是它） */
+public func bytesToHex(bytes: Array<UInt8>): String {
+    let digits = HEX_DIGITS.toArray()
+    let out = Array<UInt8>(bytes.size * 2, repeat: 0)
+    var i = 0
+    while (i < bytes.size) {
+        let b = bytes[i]
+        out[i * 2] = digits[Int64((b >> 4) & UInt8(0x0F))]
+        out[i * 2 + 1] = digits[Int64(b & UInt8(0x0F))]
+        i++
+    }
+    return String.fromUtf8(out)
+}
+
+/** 十六进制 → 字节；奇数长度或含非十六进制字符返回 None（调用方报可读错误） */
+public func hexToBytes(text: String): Option<Array<UInt8>> {
+    let src = text.toArray()
+    if (src.size % 2 != 0) {
+        return None
+    }
+    let out = Array<UInt8>(src.size / 2, repeat: 0)
+    var i = 0
+    while (i < out.size) {
+        let hi = hexDigit(src[i * 2])
+        let lo = hexDigit(src[i * 2 + 1])
+        if (hi < 0 || lo < 0) {
+            return None
+        }
+        out[i] = UInt8(hi * 16 + lo)
+        i++
+    }
+    return Some(out)
+}
+
+private func hexDigit(b: UInt8): Int64 {
+    if (b >= UInt8(48) && b <= UInt8(57)) {
+        return Int64(b - UInt8(48))
+    }
+    if (b >= UInt8(97) && b <= UInt8(102)) {
+        return Int64(b - UInt8(87))
+    }
+    if (b >= UInt8(65) && b <= UInt8(70)) {
+        return Int64(b - UInt8(55))
+    }
+    return -1
+}