cj-tauri 1.1.2 → 2.1.0

package/src/plugins/http/http_backend.cj

@@ -0,0 +1,131 @@
+package cjTauri.plugins.http
+
+import std.collection.*
+import stdx.encoding.json.*
+
+/*
+ * http 插件的**传输层契约**（两平台共用，本文件不含任何平台代码）
+ *
+ * 分工（照 AGENTS §2 的平台差异纪律）：
+ * - 本文件：回给页面的形状、流式句柄接口、**请求头解析与安全过滤**——判定只此一份；
+ * - `http_desktop.cj`（@When[env != "ohos"]）：stdx.net.http + 显式 TLS；
+ * - `http_ohos.cj`（@When[env == "ohos"]）：系统网络栈 ohos.net.http。
+ *
+ * 为什么值得抽这一层：仓颉运行时在鸿蒙上装不了 OpenSSL 3（真机
+ * `MUSL-LDSO: load libcrypto_openssl.z.so failed … errno=2`），stdx 的 TLS 从第一步就不可用，
+ * 于是 `http:get` 在鸿蒙上**必然是 https 全灭、http 照旧**——这种「半死」状态最难排查。
+ * 换系统栈之后命令名、入参、返回值、白名单判定都不变，前端契约一行都不用改。
+ */
+
+/**
+ * 一次出网请求的结果（**两平台同一形状**）
+ *
+ * 回给页面的是 `{status, contentType, body, truncated}` 四项，与 `httpReplyJson` 一一对应。
+ * `truncated` 表示「撞上 `CJ_HTTP_MAX_BYTES` 上限被截断」，不是出错。
+ */
+public class HttpReply {
+    public let status: Int64
+    public let contentType: String
+    public let body: String
+    public let truncated: Bool
+
+    public init(status: Int64, contentType: String, body: String, truncated: Bool) {
+        this.status = status
+        this.contentType = contentType
+        this.body = body
+        this.truncated = truncated
+    }
+}
+
+/** `HttpReply` → 命令返回值（两边各拼一次迟早会漂字段名，所以收在一处） */
+public func httpReplyJson(reply: HttpReply): JsonValue {
+    let obj = JsonObject()
+    obj.put("status", JsonInt(reply.status))
+    obj.put("contentType", JsonString(reply.contentType))
+    obj.put("body", JsonString(reply.body))
+    obj.put("truncated", JsonBool(reply.truncated))
+    return obj
+}
+
+/**
+ * 流式响应句柄：把「边收边发」收敛成 read / close 两步
+ *
+ * 桌面由 stdx 的响应体包装（连接与响应都归它持有，close 一并释放）；**没有流式能力的平台
+ * 在构造处如实抛错**——返回一个假句柄假装成功是不可接受的（AGENTS §1 第 4 条：
+ * 跑不起来就说跑不起来）。
+ *
+ * 句柄只被 `http:postStream` 的那条命令线程用，**不做跨线程共享**（与 stdx 响应的
+ * 单线程语义一致）。
+ */
+public interface HttpResponseStream {
+    func status(): Int64
+    func contentType(): String
+    /** 读一块进 buf，返回字节数；0 表示 EOF */
+    func read(buf: Array<Byte>): Int64
+    func close(): Unit
+}
+
+/**
+ * 解析页面给的 `headers` 对象（可选）→ 请求头表（键已小写化）
+ *
+ * 这是**安全判定**，不是格式转换，所以只写一份：条数与单条长度有上限，且
+ * **Host / Content-Length 一律剔除**——前者能改写白名单判过的目标（白名单判的是 URL 里的
+ * host），后者由库自己算，页面写进来的值与实际发出的一样才不误导。
+ * 非字符串值直接跳过（不做隐式转换：`{"X": 1}` 该被忽略，不是变成 "1"）。
+ */
+public func parsePageHeaders(args: JsonObject): HashMap<String, String> {
+    let out = HashMap<String, String>()
+    let v = match (args.get("headers")) {
+        case Some(h) => h
+        case None => return out
+    }
+    // JsonKind 没有 ==（AGENTS §4）：枚举比较只能走 match
+    let isObject = match (v.kind()) {
+        case JsonKind.JsObject => true
+        case _ => false
+    }
+    if (!isObject) {
+        return out
+    }
+    var count: Int64 = 0
+    // 遍历用 getFields()（JsonObject 不是按索引取的容器，store 插件同款先例）
+    for ((name0, value) in v.asObject().getFields()) {
+        if (count >= CJ_HTTP_MAX_HEADERS) {
+            break
+        }
+        let name = name0.toAsciiLower()
+        if (name == "host" || name == "content-length") {
+            continue
+        }
+        let isString = match (value.kind()) {
+            case JsonKind.JsString => true
+            case _ => false
+        }
+        if (!isString) {
+            continue
+        }
+        let hval = value.asString().getValue()
+        if (hval.size <= CJ_HTTP_MAX_HEADER_VALUE) {
+            out[name] = hval
+            count++
+        }
+    }
+    return out
+}
+
+/**
+ * 从响应头里取 Content-Type（同 Y 头名的**大小写不敏感**取值）
+ *
+ * 桌面侧 stdx 用 `headers.getFirst`（且**没有 get**，AGENTS §4）；鸿蒙侧 `HttpResponse.header`
+ * 是 `HashMap<String, String>` 且键保留服务端大小写，只能逐个小写比对。
+ * 两平台都要「按名字取头」这一件事，所以收成一个只吃表的纯函数，谁都能用。
+ */
+public func headerValueOf(header: HashMap<String, String>, want: String): String {
+    let lower = want.toAsciiLower()
+    for ((k, v) in header) {
+        if (k.toAsciiLower() == lower) {
+            return v
+        }
+    }
+    return ""
+}

package/src/plugins/http/http_desktop.cj

@@ -0,0 +1,195 @@
+package cjTauri.plugins.http
+
+import cjTauri.*
+
+@When[env != "ohos"]
+import std.collection.*
+
+@When[env != "ohos"]
+import std.io.*
+
+@When[env != "ohos"]
+import stdx.net.http.*
+
+@When[env != "ohos"]
+import stdx.net.tls.*
+
+/*
+ * 桌面两端的出网实现（Linux / Windows）：stdx.net.http
+ *
+ * 与鸿蒙侧的分界：本文件只在 `env != "ohos"` 编译，`http_ohos.cj` 反之。
+ * 上层（`plugin_http.cj`）只认两个函数名，不出现任何平台分支。
+ */
+
+/**
+ * 发一次请求并读完响应体（撞 `CJ_HTTP_MAX_BYTES` 上限则截断并置 `truncated`）
+ *
+ * 调用方（`HttpCommands`）已经做过主机白名单判定与参数解析——本函数只管「怎么发出去」。
+ * 三个口径与改造前完全一致，别顺手改：
+ * - **禁自动重定向**：3xx 原样回给页面，白名单只判第一跳；
+ * - 每个请求**新建 Client**（共享 Client 的线程安全性本仓没验证过，见 `HttpPlugin` 类注释）；
+ * - `resp.body` 的静态类型只有 InputStream，`readToEnd` 编译不过（泛型约束要 Seekable，
+ *   AGENTS §4），所以按块读到 EOF 或上限。
+ */
+@When[env != "ohos"]
+public func httpTransportSend(method: String, url: String, host: String,
+    headers: HashMap<String, String>, body: String): HttpReply {
+    var builder = HttpRequestBuilder().url(url)
+    if (method == "GET") {
+        builder = builder.get()
+    } else if (method == "DELETE") {
+        // DELETE 也带 JSON 体：cjh 的工作区删除靠 body 传 path（其 rest_api 的 DELETE 分支
+        // 读的就是请求体），所以这里不能走「无体 DELETE」那条路
+        builder = builder.delete().body(body)
+    } else {
+        builder = builder.post().body(body)
+    }
+    // 默认头：JSON 客户端最常见形态；页面可用 headers 覆盖/追加（Host/Content-Length 已剔除）
+    builder = builder.header("Accept", "application/json, text/event-stream, */*")
+    for ((name, value) in headers) {
+        builder = builder.header(name, value)
+    }
+
+    let client = ClientBuilder()
+        .tlsConfig(tlsConfigForHost(host))
+        .autoRedirect(false)
+        .readTimeout(Duration.second * CJ_HTTP_TIMEOUT_SECONDS)
+        .writeTimeout(Duration.second * CJ_HTTP_TIMEOUT_SECONDS)
+        .build()
+    var status: Int64 = 0
+    var ctype = ""
+    var text = ""
+    var truncated = false
+    try {
+        let resp = client.send(builder.build())
+        status = Int64(resp.status)
+        // 头名大小写在 HTTP 里不敏感，但取法只有 getFirst（**没有 get**，AGENTS §4）
+        ctype = match (resp.headers.getFirst("Content-Type")) {
+            case Some(v) => v
+            case None => ""
+        }
+        // ByteBuffer 没有 size 属性：字节数自己累加（要掐上限，所以不用现成的 readBodyBytes）
+        let buf = ByteBuffer()
+        let chunk = Array<Byte>(8192, repeat: 0)
+        var total: Int64 = 0
+        var n = resp.body.read(chunk)
+        while (n > 0) {
+            if (total + n > CJ_HTTP_MAX_BYTES) {
+                buf.write(chunk[0..(CJ_HTTP_MAX_BYTES - total)])
+                truncated = true
+                break
+            }
+            buf.write(chunk[0..n])
+            total += n
+            n = resp.body.read(chunk)
+        }
+        resp.close()
+        text = String.fromUtf8(buf.bytes())
+    } finally {
+        client.close()
+    }
+    return HttpReply(status, ctype, text, truncated)
+}
+
+/**
+ * 打开一个流式响应（SSE / 长回复增量回投用）
+ *
+ * 句柄持有 body 与 client，`close()` 一并释放——**句柄不关闭等于泄漏连接**，调用方必须
+ * 放在 finally 里。连接与响应都归这一条命令线程所有，不跨线程共享。
+ */
+@When[env != "ohos"]
+public func httpTransportOpenStream(url: String, host: String,
+    headers: HashMap<String, String>, body: String): HttpResponseStream {
+    var builder = HttpRequestBuilder().url(url).post().body(body)
+    builder = builder.header("Accept", "text/event-stream")
+    for ((name, value) in headers) {
+        builder = builder.header(name, value)
+    }
+    let client = ClientBuilder()
+        .tlsConfig(tlsConfigForHost(host))
+        .autoRedirect(false)
+        .readTimeout(Duration.second * CJ_HTTP_TIMEOUT_SECONDS)
+        .writeTimeout(Duration.second * CJ_HTTP_TIMEOUT_SECONDS)
+        .build()
+    try {
+        let resp = client.send(builder.build())
+        let ctype = match (resp.headers.getFirst("Content-Type")) {
+            case Some(v) => v
+            case None => ""
+        }
+        return StdHttpStream(Int64(resp.status), ctype, resp.body, client)
+    } catch (e: Exception) {
+        // 建连/握手/首字节就失败：client 还没交给句柄，这里必须自己收掉，否则泄漏
+        client.close()
+        throw e
+    }
+}
+
+/**
+ * stdx 响应体的流式包装
+ *
+ * 只持 `InputStream` 与 `Client`，**不持响应对象**——响应体的读与关闭已经够用，
+ * 少一个类型依赖少一处跨版本形状风险。
+ */
+@When[env != "ohos"]
+class StdHttpStream <: HttpResponseStream {
+    private let st: Int64
+    private let ct: String
+    private let body: InputStream
+    private let client: Client
+    private var closed = false
+
+    init(st: Int64, ct: String, body: InputStream, client: Client) {
+        this.st = st
+        this.ct = ct
+        this.body = body
+        this.client = client
+    }
+
+    // 接口成员隐式 public，实现类里必须显式写 public（否则报「must be at least as visible」）
+    public func status(): Int64 {
+        return this.st
+    }
+
+    public func contentType(): String {
+        return this.ct
+    }
+
+    public func read(buf: Array<Byte>): Int64 {
+        return this.body.read(buf)
+    }
+
+    /** 幂等：finally 与异常路径都可能调到，重复关不抛 */
+    public func close(): Unit {
+        if (this.closed) {
+            return
+        }
+        this.closed = true
+        try {
+            this.client.close()
+        } catch (_: Exception) {
+            // 关连接失败不影响已经收到的内容，吞掉
+        }
+    }
+}
+
+/**
+ * 建 TLS 客户端配置：**域名必须显式写 `serverName`（SNI）**
+ *
+ * stdx 的 `TlsClientConfig()` 默认不发 SNI，而多租户 HTTPS 边缘（实测 Cloudflare 后面的
+ * api 域名）收不到 SNI 就以 `handshake failure`(40) 拒掉握手——表象是「TLS 握手失败」，
+ * 同一地址 curl / openssl 打起来一切正常，极易误判成对端故障、甚至误判成白名单问题
+ * （AGENTS §4 有这条坑）。IP 字面量**不带** SNI：RFC 6066 不许，且「https 直连 IP」原本
+ * 可用，不能反被改坏。
+ *
+ * 这七行故意留在插件里而不进核心共享层：核心一引用 `stdx.net.tls`，不用 TLS 的应用也会
+ * 被拉上 OpenSSL 依赖，单文件打包契约跟着变形（§2 的包粒度纪律）；ws 插件里那份是同样的七行。
+ */
+@When[env != "ohos"]
+func tlsConfigForHost(host: String): TlsClientConfig {
+    var cfg = TlsClientConfig()
+    if (!isIpLiteralHost(host)) {
+        cfg.serverName = host
+    }
+    return cfg
+}

package/src/plugins/http/http_ohos.cj

@@ -0,0 +1,204 @@
+package cjTauri.plugins.http
+
+@When[env == "ohos"]
+import cjTauri.*
+
+@When[env == "ohos"]
+import ohos.net.http.*
+
+@When[env == "ohos"]
+import std.collection.*
+
+/*
+ * 鸿蒙侧的出网实现：系统网络栈 `ohos.net.http`（NetworkKit）
+ *
+ * ## 为什么不是 stdx.net.http
+ *
+ * 仓颉运行时在鸿蒙上**装不了 OpenSSL 3**：真机 hilog 是
+ *   `MUSL-LDSO: load libcrypto_openssl.z.so failed, namespace=moduleNs_default, errno=2`
+ * （`libssl_openssl.z.so` 同样），即运行时按名字 dlopen、设备上没有这个库。于是 stdx 的 TLS
+ * 从第一步就不可用，全部 https 当场失败、http 照旧——这种「半死」状态最容易误判成网络/权限问题
+ * （AGENTS §4 有完整形状，判据见 `docs/鸿蒙ArkWeb接入踩坑.md` §10.15）。
+ *
+ * 换成系统栈之后 TLS / 证书链 / 代理都交给 OS，本文件只管组请求、等结果、解码。
+ * **不要**往 hap 里塞 OpenSSL：运行时是 musl 静态链，AOSP 那份的 ABI 与符号都对不上。
+ *
+ * ## 为什么这里是阻塞等回调
+ *
+ * `HttpRequest.request` 只有回调形态（没有同步版本），而命令 handler 跑在框架的 worker
+ * 线程上（不是 UI 线程），所以「发请求 → sleep 轮询等回调」是安全的：冻不住界面。
+ * **这个写法不能搬到 UI 线程**（那会把界面卡满整个超时预算）。
+ *
+ * ## 形状依据与未验证项（本机没有鸿蒙仓颉工具链，编不了这一支）
+ *
+ * 建客户端的调用形状照抄 `examples/ohos/ohos-movie/entry/src/main/cangjie/ohos_movie_image.cj`
+ * ——那份是**真机验证过**的（`client.request(url, options) { err, resp => … }` 位置参数 + 尾随
+ * 闭包、`HttpDataType.ArrayBuffer`、`resp.responseCode` / `resp.result` / `resp.header`、
+ * `client.destroy()`）。两处是本机核不到、要在真机构建时确认的：
+ * ① `RequestMethod` 的成员名（`Get` 是 precedent 里的写法，`Post` / `Delete` 按同一命名风格推）；
+ * ② `HttpRequestOptions.extraData` 承载 POST 体（官方文档确认该字段存在，仓内无用法先例）。
+ * 真机首跑若在这两处报错，改的是**这一支**，不要回头动 `plugin_http.cj`（命令面对两平台一致）。
+ */
+
+/** 轮询回调的间隔（毫秒）：与 ohos-movie 取封面的轮询同口径 */
+@When[env == "ohos"]
+let OHOS_HTTP_POLL_MS: Int64 = 20
+
+/**
+ * 回调与命令线程之间搬结果用的盒子
+ *
+ * 仓颉的 lambda **不能捕获可变的局部变量**（AGENTS §4），所以结果装在对象里、闭包只改字段。
+ * 回调线程与轮询线程之间没有加锁——与真机验证过的 `ohos_movie_image.cj` 同形（那边同样只写
+ * `done` / `bytes` 这类简单字段）。真要改成并发安全的，两边得一起改，别只改这边。
+ */
+@When[env == "ohos"]
+class OhosHttpFeed {
+    var done = false
+    var failure: Option<String> = None
+    var status: Int64 = 0
+    var bytes: Array<Byte> = []
+    var contentType: String = ""
+}
+
+/** 命令的 HTTP 方法 → 系统栈的枚举（GET 是兜底：本插件只会传这三者之一） */
+@When[env == "ohos"]
+func ohosMethodOf(method: String): RequestMethod {
+    if (method == "POST") {
+        return RequestMethod.Post
+    }
+    if (method == "DELETE") {
+        return RequestMethod.Delete
+    }
+    return RequestMethod.Get
+}
+
+/** 把响应体统一成字节：期望类型是 ArrayBuffer，个别实现仍可能回字符串 */
+@When[env == "ohos"]
+func ohosResponseBytes(data: HttpData): Array<Byte> {
+    match (data) {
+        case ArrayData(b) => return b
+        case StringData(s) => return s.toArray()
+        case _ => return Array<Byte>()
+    }
+}
+
+/**
+ * 发一次请求，返回 `(状态码, Content-Type, 响应体字节)`
+ *
+ * 失败一律转成 `CommandException`（业务错误）：命令面回给页面的是业务错误，不是框架内部异常。
+ * 超时既可能是 `request` 同步抛、也可能是回调来得太晚，两种都收口到同一句话。
+ */
+@When[env == "ohos"]
+func ohosRequest(method: String, url: String, headers: HashMap<String, String>,
+    body: String): (Int64, String, Array<Byte>) {
+    let feed = OhosHttpFeed()
+    // 页面头原样带上（Host / Content-Length 已在 parsePageHeaders 里剔除——判定只在那份）
+    let hdrs = HashMap<String, String>()
+    for ((k, v) in headers) {
+        hdrs[k] = v
+    }
+    if (!hdrs.contains("accept")) {
+        // 默认头与非流式命令的桌面侧一致（页面给了就尊重页面的）
+        hdrs["Accept"] = "application/json, text/event-stream, */*"
+    }
+    let timeoutMs = UInt32(CJ_HTTP_TIMEOUT_SECONDS * 1000)
+    let client = createHttp()
+    try {
+        // GET 不带体：extraData 在 GET 上会被拼成查询参数，所以两种形状分开构造
+        let options = if (method == "GET") {
+            HttpRequestOptions(
+                method: RequestMethod.Get,
+                expectDataType: HttpDataType.ArrayBuffer,
+                header: hdrs,
+                readTimeout: timeoutMs,
+                connectTimeout: timeoutMs
+            )
+        } else {
+            HttpRequestOptions(
+                method: ohosMethodOf(method),
+                extraData: StringData(body),
+                expectDataType: HttpDataType.ArrayBuffer,
+                header: hdrs,
+                readTimeout: timeoutMs,
+                connectTimeout: timeoutMs
+            )
+        }
+        client.request(url, options) { err, resp =>
+            match (err) {
+                case Some(e) => feed.failure = Some("${e}")
+                case None => ()
+            }
+            match (resp) {
+                case Some(r) =>
+                    feed.status = Int64(r.responseCode)
+                    feed.bytes = ohosResponseBytes(r.result)
+                    feed.contentType = headerValueOf(r.header, "content-type")
+                case None => ()
+            }
+            feed.done = true
+        }
+    } catch (e: Exception) {
+        // 同步抛：缺 ohos.permission.INTERNET、明文流量被策略拦、域名不可达等
+        feed.failure = Some("${e}")
+        feed.done = true
+    }
+
+    // 等回调：命令在 worker 线程上跑，这里阻塞不会冻界面（见文件头「为什么这里是阻塞的」）
+    let budgetMs = CJ_HTTP_TIMEOUT_SECONDS * 1000
+    var waited: Int64 = 0
+    while (!feed.done && waited < budgetMs) {
+        sleep(Duration.millisecond * OHOS_HTTP_POLL_MS)
+        waited += OHOS_HTTP_POLL_MS
+    }
+    try {
+        client.destroy()
+    } catch (_: Exception) {
+        // 释放失败不影响结论（这个 client 用完即弃，每条命令自己建一个）
+    }
+
+    if (let Some(msg) <- feed.failure) {
+        eprintln("[cj-tauri] http transport failed (ohos): ${msg}")
+        throw CommandException("http: request failed on HarmonyOS: ${msg}")
+    }
+    if (!feed.done) {
+        eprintln("[cj-tauri] http transport timeout (ohos): ${waited}ms ${url}")
+        throw CommandException("http: no response within ${waited}ms on HarmonyOS")
+    }
+    return (feed.status, feed.contentType, feed.bytes)
+}
+
+/** 非流式请求：与桌面侧同一契约（截断口径、Content-Type 取值都在这里对齐） */
+@When[env == "ohos"]
+public func httpTransportSend(method: String, url: String, host: String,
+    headers: HashMap<String, String>, body: String): HttpReply {
+    // host 只在建 TLS 时用得上（桌面侧写 SNI）；鸿蒙把 TLS 交给系统，按 URL 里的域名自动协商
+    let _ = host
+    let (status, ctype, bytes) = ohosRequest(method, url, headers, body)
+    var truncated = false
+    var cut = bytes.size
+    if (cut > CJ_HTTP_MAX_BYTES) {
+        cut = CJ_HTTP_MAX_BYTES
+        truncated = true
+    }
+    return HttpReply(status, ctype, String.fromUtf8(bytes[0..cut]), truncated)
+}
+
+/**
+ * 流式请求：**鸿蒙侧如实拒绝**，不假装成功
+ *
+ * 系统栈的 `request` 一次回整包（`requestInStream` + `dataReceive` 是 ArkTS 侧 API 18 起的形态，
+ * 仓颉绑定上**没有验证过**，本机也没有鸿蒙工具链可核）——所以这里宁可当场报「不可用」，
+ * 也不返回一个永远读到 EOF 的假句柄：那种失败在页面上表现为「模型一句话都不回」，
+ * 没有凭证、极难排查（AGENTS §1 第 4 条：跑不起来就说跑不起来）。
+ * 命令本身照常注册、白名单照常判定——不可用的是**流式这一种取法**，不是整条出网链路。
+ */
+@When[env == "ohos"]
+public func httpTransportOpenStream(url: String, host: String,
+    headers: HashMap<String, String>, body: String): HttpResponseStream {
+    let _ = url
+    let _ = host
+    let _ = headers
+    let _ = body
+    throw CommandException(
+        "http:postStream is not available on HarmonyOS: the system network stack returns the whole body at once (no incremental chunks). Use http:post instead.")
+}