cj-tauri 0.8.0 → 1.1.1

package/README.md

@@ -1,11 +1,11 @@
 # cj-tauri
 
-用[仓颉语言](https://cangjie-lang.cn)写桌面应用的**类 Tauri 框架**脚手架 CLI：
-仓颉后端（静态编译）+ 系统 WebView 前端（HTML/CSS/JS），三件套对标 Tauri ——
+用[仓颉语言](https://cangjie-lang.cn)写桌面应用的脚手架 CLI——把 Tauri 的三件套带到仓颉：
+仓颉后端（静态编译）+ 系统 WebView 前端（HTML/CSS/JS），三件套与 Tauri 一致 ——
 WebView 宿主、IPC 双向桥（`invoke` / `resolve` / `event`）、能力安全模型（capability 白名单）。
 
 - 仓库与完整文档：<https://atomgit.com/qq8864/cj-tauri>
-- 当前状态：**Windows（WebView2）与 Linux（WebKitGTK）均已实机跑通**；鸿蒙 ArkWeb 为架构预留位
+- 当前状态：**Windows（WebView2）、Linux（WebKitGTK）与鸿蒙 PC（ArkWeb）均已实机跑通**
 
 ## 前置条件：仓颉 SDK
 
@@ -40,18 +40,64 @@ npx cj-tauri dev                   # 构建 C 桥 + cjpm build + 启动窗口
 npx cj-tauri create myapp-vue --template vue      # Vue 3 + Vite
 npx cj-tauri create myapp-react --template react  # React 18 + Vite
 
+npx cj-tauri create myohos --template ohos        # 鸿蒙 PC（2in1）工程：ArkWeb 宿主 + build-hap.sh
+npx cj-tauri create myohos --template ohos --bundle com.example.myapp --label "我的应用"
+
 npm i -g cj-tauri                  # 也可以全局安装，之后直接用 cj-tauri <子命令>
 ```
 
 | 子命令 | 作用 |
 |---|---|
-| `create <项目名> [--template app\|vue\|react]` | 生成工程（`src/` + `ui/` + `capabilities/` + `cjpm.toml`） |
-| `dev` | 构建 C 桥 + `cjpm build` + 启动应用；Vite 模板会接管 dev server（HMR） |
-| `build` | 构建 C 桥 + `cjpm build` |
-| `run` | 运行已构建产物 |
+| `create <项目名> [--template app\|vue\|react\|ohos]` | 生成工程（桌面模板：`src/` + `ui/` + `capabilities/` + `cjpm.toml`；`ohos` 见下一节） |
+| `dev` | 构建 C 桥 + `cjpm build` + 启动应用；Vite 模板会接管 dev server（HMR）；鸿蒙工程转交 `build-hap.sh` |
+| `build` | 构建 C 桥 + `cjpm build`；鸿蒙工程转交 `build-hap.sh` |
+| `run` | 运行已构建产物；鸿蒙工程转交 `build-hap.sh --install`（构建 + 装机 + 启动） |
 | `info` | 环境自检（排障先跑它） |
 | `help` | 帮助 |
 
+## 鸿蒙 PC（`--template ohos`）
+
+同一套框架换个宿主：桌面用 WebView2 / WebKitGTK，鸿蒙 PC 用 **ArkWeb**，上层页面、命令层、能力校验不用改。
+
+```bash
+npx cj-tauri create myohos --template ohos
+cd myohos
+bash build-hap.sh --install        # 构建 hap + hdc 装机 + aa start；等价于 npx cj-tauri run
+```
+
+生成的是标准 DevEco 工程（`entry/` + `AppScope/` + `build-profile.json5` + `hvigorfile.ts`），
+鸿蒙相关的那层很薄：
+
+| 路径 | 作用 |
+|---|---|
+| `entry/src/main/cangjie/main_ability.cj` | UIAbility：`ArkWebRuntime.configure(filesDir)` → 非 UI 线程 `spawn { run() }` → 等宿主登记再 `loadContent` |
+| `entry/src/main/cangjie/index.cj` | `@Component` 的 ArkWeb 宿主 + 双向桥（**必须住应用模块**，框架包引用 ArkUI 会启动即崩） |
+| `entry/src/main/resources/rawfile/` | `index.html`（页面真文件）与 `capabilities.json`（能力清单） |
+| `build-hap.sh` | 唯一构建入口：探测 DevEco / stdx、`--no-daemon` 跑 hvigor、可选 `--install` |
+
+前置两件事：
+
+- **DevEco Studio 6.1**（含仓颉插件）+ 已配好签名。`build-hap.sh` 用 `DEVECO_WIN` 找安装根
+  （默认 `D:\oh\DevEcoStudio`），用 `CANGJIE_STDX_OHOS` 找鸿蒙版 stdx 动态库；两者给不出时脚本会直接说清楚缺哪个。
+- 真机开着**开发者模式 + USB 调试**，`hdc` 能列到设备；`aa start` 需要**屏幕已解锁**。
+
+工程默认是桌面形态：`module.json5` 的 `deviceTypes` 写 `2in1`，并在 `entry/build-profile.json5` 里
+`cangjieOptions.checkDeviceTypes = false`（插件默认只放行 `phone` / `tablet`，写 `2in1` 会判 `01103012`）；
+窗口**不干预尺寸**，沿用系统给的默认矩形（实测本机 `2090×1394`，约屏宽 2/3 且居中）。
+
+已知限制：签名要在 DevEco 里配（命令行不做自动签名，换 `bundleName` 需重新签）；同一份调试签名下两个
+工程会互相顶掉安装位；单窗口、暂无原生对话框（那两条能力位如实返回 0）；没有可用的 C 桥，
+`launchHidden` / 串口 / 托盘这类宿主能力在鸿蒙上不提供。
+
+真机上怎么自证它通了（hilog，`CjTauri` tag）：
+
+```
+host registered after N polls label=main
+host pageUrl label=main url="file:///.../files/cj-tauri-main.html"
+page begin label=main
+main window keeps system default 2090x1394 px at density 190% on screen 3120x2080
+```
+
 ## 这个包装层做了什么
 
 - **跨平台入口**：Windows / Linux / Git Bash 都是同一条 `cj-tauri` 命令，不再分 `.bat` 与 `.sh`；

package/cjpm.toml

@@ -1,25 +1,52 @@
-[package]
-  cjc-version = "1.0.5"
-  name = "cjTauri"
-  description = "仓颉版 Tauri：轻量跨端混合开发框架（WebView 宿主 + IPC 桥 + 能力安全模型）"
-  version = "0.8.0"
-  target-dir = ""
-  output-type = "static"
-  compile-option = ""
-  override-compile-option = ""
-  link-option = ""
-  package-configuration = {}
-
-[dependencies]
-
-[target.x86_64-unknown-linux-gnu]
-  link-option = "-Lnative -lcjtbridge -lwebkit2gtk-4.1 -lgtk-3 -lgdk-3 -lglib-2.0 -lgio-2.0 -lsoup-3.0 -ljavascriptcoregtk-4.1 -lgobject-2.0"
-
-[target.x86_64-unknown-linux-gnu.bin-dependencies]
-    path-option = ["/root/.cangjie/stdx/cangjie-stdx-linux-x64-1.0.5.1/dynamic/stdx"]
-
-[target.x86_64-w64-mingw32]
-  link-option = "-Lnative -lcjtbridge"
-
-[target.x86_64-w64-mingw32.bin-dependencies]
-    path-option = ["D:\\cangjie-stdx\\windows_x86_64_cjnative\\dynamic\\stdx"]
+[package]
+  cjc-version = "1.0.5"
+  name = "cjTauri"
+  description = "仓颉版 Tauri：轻量跨端混合开发框架（WebView 宿主 + IPC 桥 + 能力安全模型）"
+  version = "1.1.1"
+  target-dir = ""
+  output-type = "static"
+  compile-option = ""
+  override-compile-option = ""
+  link-option = ""
+  package-configuration = {}
+
+[dependencies]
+
+[target.x86_64-unknown-linux-gnu]
+  # -lsqlite3：sqlite 插件直连发行版系统库（D-018 第 8 条）；Windows 侧未落地，故 mingw 段不加
+  link-option = "-Lnative -lcjtbridge -lsqlite3 -lwebkit2gtk-4.1 -lgtk-3 -lgdk-3 -lglib-2.0 -lgio-2.0 -lsoup-3.0 -ljavascriptcoregtk-4.1 -lgobject-2.0"
+
+[target.x86_64-unknown-linux-gnu.bin-dependencies]
+    path-option = ["${CANGJIE_STDX}"]
+
+[target.x86_64-w64-mingw32]
+  # -lsqlite3：sqlite 插件子包需要（导入库 libsqlite3.a 由 sqlite3.def 生成，DLL 本身不入库——
+  # 跑 sqlite 相关测试/应用时本机自备 native/sqlite3.dll；不碰 sqlite 的应用不引用它就不链接）
+  link-option = "-Lnative -lcjtbridge -lsqlite3"
+
+[target.x86_64-w64-mingw32.bin-dependencies]
+    path-option = ["${CANGJIE_STDX}"]
+
+[target.aarch64-linux-ohos]
+  # 鸿蒙目标（真机 / 鸿蒙 PC）：交叉编译工具链与 sysroot 由 DevEco 仓颉套件提供，
+  # 四个路径全部走环境变量展开——hvigor 构建时由插件注入前两个，命令行交叉编译时自行 export 同名变量。
+  # 照抄 DevEco 生成的工程（TestCj2）同一串参数，避免两套口径。
+  # 末尾的 `--dy-std` 不可省：鸿蒙上应用模块（entry）是 `output-type = "dynamic"` 且用动态 std，
+  # 框架包若按默认的静态 std 编，两者混进同一个 .so 就会出现**两套 std 运行时**——表象是
+  # 启动即崩在框架包全局初始化（`cjTauri::package_global_init` → 跨包 `_CGP*` 包初始化符号
+  # 解析到模块内偏移、跳到未映射地址 0x50xxx），窗口起不来且 hilog 只有一行 SIGSEGV。
+  # 只加在鸿蒙段：桌面两平台仍是静态 std，产物形态不变。
+  compile-option = "-B \"${DEVECO_CANGJIE_HOME}/build-tools/third_party/llvm/bin\" -B \"${DEVECO_OH_NATIVE_HOME}/sysroot/usr/lib/aarch64-linux-ohos\" -L \"${DEVECO_OH_NATIVE_HOME}/sysroot/usr/lib/aarch64-linux-ohos\" -L \"${DEVECO_OH_NATIVE_HOME}/llvm/lib/clang/15.0.4/lib/aarch64-linux-ohos\" -L \"${DEVECO_OH_NATIVE_HOME}/llvm/lib/aarch64-linux-ohos\" --sysroot \"${DEVECO_OH_NATIVE_HOME}/sysroot\" --dy-std"
+
+[target.aarch64-linux-ohos.bin-dependencies]
+    # stdx 必须用鸿蒙版（官方发布 cangjie-stdx-ohos-aarch64-<cjc 版本>.zip，桌面版 ABI 不通）；
+    # CANGJIE_OHOS_LIBS 指 DevEco 套件的 api/lib/linux_ohos_aarch64_cjnative/ohos（仓颉标准库 + ohos API 绑定）。
+    #
+    # 后两项是 ArkUI 的**宏库**与 kit 绑定，hvigor 构建时由 cangjie-build-support 注入
+    # （cangjie-path-impl.js 的 getBuildEnvByAbi）：AARCH64_MACRO_LIBS = <sdk>/api/macro/ohos
+    # （`lib-macro_ohos.arkui.state_macro_manage.dll` 就在里面），AARCH64_KIT_LIBS =
+    # .../linux_ohos_aarch64_cjnative/kit。**宏库目录漏挂的症状极具误导性**：`@Component` 的
+    # 声明能解析到（.cjo 在 ohos 目录里），但宏实现库找不到，报的是
+    # `macro evaluation has failed for macro call 'Component'`——看着像「宏不能用在框架包里」。
+    # 命令行交叉编译时这两个变量要自己 export，取值见上。
+    path-option = ["D:/cangjie-stdx-ohos/linux_ohos_aarch64_cjnative/dynamic/stdx", "C:/Users/yang/.cangjie-sdk/6.1/cangjie/api/lib/linux_ohos_aarch64_cjnative/ohos", "${AARCH64_MACRO_LIBS}", "${AARCH64_KIT_LIBS}"]

package/cli/cjpm.toml

@@ -2,7 +2,7 @@
   cjc-version = "1.0.5"
   name = "cli"
   description = "cj-tauri CLI：脚手架 create / dev / build / run / info"
-  version = "0.8.0"
+  version = "1.1.1"
   target-dir = ""
   output-type = "executable"
   compile-option = ""

package/cli/src/doctor.cj

@@ -0,0 +1,304 @@
+/**
+ * cj-tauri CLI：环境自检（doctor）
+ *
+ * 为什么要有它：`info` 打印的是「解析结果」（路径是什么），能用但看不出「这条到底算不算过」——
+ * 每条都只是一行文本，人得自己对照 skill 里的判据。doctor 反过来：**每条检查自带结论**，
+ * 失败的给出下一步该干什么，让用户拿到包第一件事不用读文档。
+ *
+ * 判据与坑（与 skills/cj-tauri-env 同口径，两处必须一起改）：
+ *   - 判「命令可用」一律以**命令自身退出码**为准，不能用 `command -v`：
+ *     cjc / cjpm 本身是仓颉程序，二进制在 PATH 里但没设 LD_LIBRARY_PATH 时
+ *     照样加载不了运行时——stdout 空、exit=127，而路径查得到。
+ *   - Linux 上仓颉运行时 .so **不查 PATH**，只设 PATH 的表现是「找不到 libcangjie-runtime.so」。
+ *   - `CANGJIE_STDX` 必须指 stdx 的**动态库目录**（<stdx>/<三元组>/dynamic/stdx），
+ *     指到包根也能过 create，要到新工程里 cjpm build 才报 dependency info is missing。
+ */
+package cli
+
+import std.fs.*
+import std.process.*
+import std.time.*
+
+/** 一条检查的结论：ok / warn / fail（只有 fail 影响退出码） */
+enum CheckLevel {
+    | Ok
+    | Warn
+    | Fail
+}
+
+/** doctor 的自检结果统计 */
+class DoctorReport {
+    var okCount = 0
+    var warnCount = 0
+    var failCount = 0
+
+    func record(level: CheckLevel): Unit {
+        match (level) {
+            case Ok => this.okCount++
+            case Warn => this.warnCount++
+            case Fail => this.failCount++
+        }
+    }
+}
+
+/**
+ * 打印一行检查结论并计入统计：`  ok    项目名 : 说明`；失败时另起一行给「怎么办」。
+ * 计数与打印绑在一起，避免「打了 ok 却没记账」这类统计与输出不一致的假象
+ * （第一版就是各调用点手写 record，结果 ok 行全没计数，汇总报成 0 项通过）。
+ */
+func doctorLine(rep: DoctorReport, level: CheckLevel, label: String, detail: String, hint: String): Unit {
+    rep.record(level)
+    let tag = match (level) {
+        case Ok => "ok  "
+        case Warn => "warn"
+        case Fail => "FAIL"
+    }
+    println("  ${tag}  ${label} : ${detail}")
+    if (hint.size > 0) {
+        println("          → ${hint}")
+    }
+}
+
+/** 跑一条命令取 (退出码, 首行非空 stdout)，命令不存在时返回 (-1, "") */
+func doctorProbe(exe: String, argv: Array<String>): (Int64, String) {
+    try {
+        // executeWithOutput 的 stdout 是 Array<UInt8>，按 UTF-8 解回字符串再按行取首行
+        let (code, rawOut, _) = executeWithOutput(exe, argv)
+        for (line in String.fromUtf8(rawOut).split("\n")) {
+            let t = trimAscii(line)
+            if (t.size > 0) {
+                return (code, t)
+            }
+        }
+        return (code, "")
+    } catch (e: Exception) {
+        let _ = e
+        return (-1, "")
+    }
+}
+
+/**
+ * 环境自检逐行输出。返回 0 = 必需项全过（warn 不算失败）；1 = 有必需项失败。
+ *
+ * 必需项：cjc、cjpm、stdx、框架根、C 桥；其余是 warn（如项目不在、产物未构建、
+ * Windows 的 WebView2 提示）——那些是「还没到那一步」，不是环境坏。
+ */
+func cmdDoctor(): Int64 {
+    let rep = DoctorReport()
+    println("cj-tauri doctor — 环境自检（CLI ${cliVersion()}）")
+    println("")
+
+    // ---- 基本环境 ----
+    doctorLine(rep, CheckLevel.Ok, "宿主平台", "${hostOsName()} (${hostTriple()})", "")
+    doctorLine(rep, CheckLevel.Ok, "工作目录", currentDir(), "")
+
+    // ---- 仓颉 SDK ----
+    let home = resolveCangjieHome()
+    match (home) {
+        case Some(h) =>
+            doctorLine(rep, CheckLevel.Ok, "CANGJIE_HOME", h, "")
+        case None =>
+            doctorLine(rep, CheckLevel.Fail, "CANGJIE_HOME", "未找到",
+                "设置 CANGJIE_HOME，或把 SDK 的 bin 加进 PATH（doctor 从 cjc 反推）")
+    }
+
+    let (cjcCode, cjcVer) = doctorProbe("cjc", ["-v"])
+    if (cjcCode == 0) {
+        doctorLine(rep, CheckLevel.Ok, "cjc", cjcVer, "")
+    } else {
+        // 退出码 127 = 二进制在 PATH 里但运行时加载不了（Linux 上就是 LD_LIBRARY_PATH 没设）
+        let why = if (cjcCode == 127) {
+            "在 PATH 里但运行不了（exit=127，通常是 LD_LIBRARY_PATH 缺仓颉运行时）"
+        } else {
+            "不可用（exit=${cjcCode}）"
+        }
+        doctorLine(rep, CheckLevel.Fail, "cjc", why,
+            "把 SDK 的 bin 加进 PATH；Linux 另需把 runtime/lib/<平台> 加进 LD_LIBRARY_PATH")
+    }
+
+    let (cjpmCode, cjpmVer) = doctorProbe("cjpm", ["-v"])
+    if (cjpmCode == 0) {
+        doctorLine(rep, CheckLevel.Ok, "cjpm", cjpmVer, "")
+    } else {
+        doctorLine(rep, CheckLevel.Fail, "cjpm", "不可用（exit=${cjpmCode}）",
+            "把 SDK 的 tools/bin 加进 PATH（cjpm 还需要 tools/lib 与运行时）")
+    }
+
+    match (home) {
+        case Some(h) =>
+            match (findRuntimeLibDir(h)) {
+                case Some(rt) =>
+                    // Linux 上「目录存在」不等于「已设进环境」——见文件头判据
+                    if (hostIsWindows()) {
+                        doctorLine(rep, CheckLevel.Ok, "仓颉运行时", rt, "")
+                    } else {
+                        let ld = envOr("LD_LIBRARY_PATH", "")
+                        if (ld.contains(rt)) {
+                            doctorLine(rep, CheckLevel.Ok, "仓颉运行时", "${rt} [已进 LD_LIBRARY_PATH]", "")
+                        } else {
+                                        doctorLine(rep, CheckLevel.Warn, "仓颉运行时",
+                                "${rt} [不在 LD_LIBRARY_PATH]",
+                                "export LD_LIBRARY_PATH=\"${rt}:${'$'}LD_LIBRARY_PATH\"（CLI 自身会把子进程补上，手敲 cjc 才需要）")
+                        }
+                    }
+                case None =>
+                            doctorLine(rep, CheckLevel.Fail, "仓颉运行时", "在 SDK 下未找到 runtime/lib/<平台>",
+                        "检查 SDK 是否解压完整（runtime/lib/linux_x86_64_cjnative 等）")
+            }
+        case None => ()
+    }
+
+    // ---- 框架根 / stdx / C 桥 ----
+    var fwRoot = ""
+    match (resolveFrameworkRoot()) {
+        case Some(fw) =>
+            fwRoot = fw
+            doctorLine(rep, CheckLevel.Ok, "框架根目录", fw, "")
+        case None =>
+            doctorLine(rep, CheckLevel.Fail, "框架根目录", "未找到",
+                "在框架仓库内运行，或设置 CJ_TAURI_ROOT 指向框架根")
+    }
+
+    let projRoot = findProjectRoot()
+    // 显式标注：if 两分支各自返回 Option<String> / None，不标注会让类型推断拿不到实参
+    let stdx: Option<String> = if (fwRoot.size > 0) {
+        resolveStdx(fwRoot, projRoot)
+    } else {
+        None
+    }
+    match (stdx) {
+        case Some(s) =>
+            // 指到包根时 stdx 目录本身也存在，但 build 会报 dependency info is missing：
+            // 这里按「里面有没有 .so / 目录是否叫 stdx」粗判一次，把坑提前暴露
+            doctorLine(rep, CheckLevel.Ok, "stdx", s, "")
+        case None =>
+            doctorLine(rep, CheckLevel.Fail, "stdx", "未找到",
+                "设置 CANGJIE_STDX 指向 <stdx>/<三元组>/dynamic/stdx（动态库目录，不是包根）")
+    }
+
+    if (fwRoot.size > 0) {
+        let nativeDir = joinPath(fwRoot, "native")
+        let lib = joinPath(nativeDir, bridgeLibName())
+        if (exists(lib)) {
+            // 桥是本地产物、不入库：源码新过产物说明改了 C 桥没重建，链接期会 undefined reference
+            let newestSrc = newestBridgeSource(nativeDir)
+            if (newestSrc.size > 0 && FileInfo(lib).lastModificationTime < FileInfo(newestSrc).lastModificationTime) {
+                doctorLine(rep, CheckLevel.Warn, "C 桥", "${lib} [比源码旧]",
+                    "改了 C 桥要重建：Linux `bash native/build_linux.sh`、Windows `native\\build_win.bat`")
+            } else {
+                doctorLine(rep, CheckLevel.Ok, "C 桥", "${lib} [已构建]", "")
+            }
+        } else {
+            doctorLine(rep, CheckLevel.Fail, "C 桥", "${lib} 不存在",
+                "`cj-tauri build` / `dev` 会自动构建；手敲则跑 native/build_linux.sh 或 build_win.bat")
+        }
+    }
+
+    // ---- 项目（可选：不在项目里不算环境问题） ----
+    match (projRoot) {
+        case Some(proj) =>
+            doctorLine(rep, CheckLevel.Ok, "项目根目录", proj, "")
+            match (findAppBinary(proj)) {
+                case Some(bin) =>
+                    if (fwRoot.size > 0 && !appBinaryIsFresh(bin, fwRoot)) {
+                                doctorLine(rep, CheckLevel.Warn, "可执行产物", "${bin} [比框架源码旧]",
+                            "改了框架要重建应用：`cj-tauri build`（旧产物认不出新环境变量，会让 info 卡住）")
+                    } else {
+                        doctorLine(rep, CheckLevel.Ok, "可执行产物", bin, "")
+                    }
+                case None =>
+                        doctorLine(rep, CheckLevel.Warn, "可执行产物", "未构建", "`cj-tauri build`")
+            }
+        case None =>
+            doctorLine(rep, CheckLevel.Warn, "项目根目录", "当前不在 cj-tauri 项目内",
+                "cd 到项目根（有 cjpm.toml 的那层）再跑 build / dev")
+    }
+
+    // ---- 图形栈（Linux 必需；Windows 由 WebView2 承担） ----
+    if (hostIsWindows()) {
+        doctorLine(rep, CheckLevel.Ok, "WebView2", "由系统提供（Win11 自带 Runtime）",
+            "构建桥时 WebView2 SDK 版本不得高于本机 Runtime 版本")
+    } else {
+        doctorCheckLinuxGraphics(rep)
+    }
+
+    // ---- 汇总 ----
+    println("")
+    println("检查完毕：${rep.okCount} 项通过，${rep.warnCount} 项告警，${rep.failCount} 项失败")
+    if (rep.failCount > 0) {
+        println("按上面每条 FAIL 的 → 提示逐条补齐；只到 warn 说明环境够跑，只是还没到那一步。")
+        return 1
+    }
+    println("环境齐了（warn 项按需处理）。")
+    return 0
+}
+
+/**
+ * Linux 图形栈检查：C 桥的链接与运行都依赖 WebKitGTK / GTK3，缺 pkg-config 或开发包
+ * 会在链接期（找不到 -lwebkit2gtk-4.1）或运行期（找不到 .so）炸，提前在这里暴露。
+ */
+func doctorCheckLinuxGraphics(rep: DoctorReport): Unit {
+    let (pkgCode, _) = doctorProbe("pkg-config", ["--version"])
+    if (pkgCode != 0) {
+        doctorLine(rep, CheckLevel.Fail, "pkg-config", "不可用",
+            "sudo apt install pkg-config gcc libwebkit2gtk-4.1-dev libgtk-3-dev")
+        return
+    }
+    let (wCode, wVer) = doctorProbe("pkg-config", ["--modversion", "webkit2gtk-4.1"])
+    if (wCode == 0 && wVer.size > 0) {
+        doctorLine(rep, CheckLevel.Ok, "webkit2gtk-4.1", wVer, "")
+    } else {
+        doctorLine(rep, CheckLevel.Fail, "webkit2gtk-4.1", "未找到",
+            "sudo apt install libwebkit2gtk-4.1-dev（C 桥链接它）")
+    }
+    let (gCode, gVer) = doctorProbe("pkg-config", ["--modversion", "gtk+-3.0"])
+    if (gCode == 0 && gVer.size > 0) {
+        doctorLine(rep, CheckLevel.Ok, "gtk+-3.0", gVer, "")
+    } else {
+        doctorLine(rep, CheckLevel.Fail, "gtk+-3.0", "未找到",
+            "sudo apt install libgtk-3-dev（C 桥链接它）")
+    }
+    let (cCode, cVer) = doctorProbe("gcc", ["--version"])
+    if (cCode == 0) {
+        doctorLine(rep, CheckLevel.Ok, "gcc", cVer, "")
+    } else {
+        doctorLine(rep, CheckLevel.Fail, "gcc", "不可用",
+            "sudo apt install gcc（构建 C 桥）")
+    }
+}
+
+/**
+ * 框架 native/ 下最新的 C 源文件（含 core/ 与 platforms/），用于判桥产物新不新。
+ * 找不到任何源文件时返回空串（调用方跳过新旧比较）。
+ */
+func newestBridgeSource(nativeDir: String): String {
+    var newest = ""
+    // FileInfo.lastModificationTime 是 DateTime（不是 epoch 整数），比较用 Option 装上一个值；
+    // 带泛型实参的 None 必须写全，裸 None 推不出 Option<T> 的实参
+    var newestTime: Option<DateTime> = Option<DateTime>.None
+    let dirs = [joinPath(nativeDir, "core"), joinPath(joinPath(nativeDir, "platforms"), hostOsName())]
+    for (d in dirs) {
+        if (!exists(d)) {
+            continue
+        }
+        for (f in Directory.readFrom(d)) {
+            let name = f.name
+            if (!(name.endsWith(".c") || name.endsWith(".h"))) {
+                continue
+            }
+            let full = joinPath(d, name)
+            let t = FileInfo(full).lastModificationTime
+            match (newestTime) {
+                case None =>
+                    newestTime = Some(t)
+                    newest = full
+                case Some(prev) =>
+                    if (t > prev) {
+                        newestTime = Some(t)
+                        newest = full
+                    }
+            }
+        }
+    }
+    return newest
+}

package/cli/src/main.cj

@@ -7,13 +7,16 @@ func usage(): Unit {
     println("cj-tauri ${cliVersion()} — 仓颉版 Tauri CLI（脚手架 + 构建 + 运行）")
     println("")
     println("用法:")
-    println("  cj-tauri create <项目名> [--template <t>]")
+    println("  cj-tauri create <项目名> [--template <t>] [--bundle <bundleName>] [--label <应用名>]")
     println("                             创建新项目（src/ + ui/ + capabilities/ + cjpm.toml）")
     println("                             模板: app（内联单文件，缺省）/ vue / react")
-    println("  cj-tauri dev               构建 C 桥 + cjpm build + 启动应用")
-    println("  cj-tauri build             构建 C 桥 + cjpm build")
-    println("  cj-tauri run               运行已构建产物")
+    println("                                   ohos（鸿蒙 PC / 2in1：ArkWeb 宿主 + build-hap.sh）")
+    println("                             --bundle / --label 只对 ohos 模板有意义（缺省由项目名推导）")
+    println("  cj-tauri dev               构建 C 桥 + cjpm build + 启动应用（鸿蒙工程改走 build-hap.sh）")
+    println("  cj-tauri build             构建 C 桥 + cjpm build（鸿蒙工程 = 编 hap）")
+    println("  cj-tauri run               运行已构建产物（鸿蒙工程 = 装到设备并拉起）")
     println("  cj-tauri info [--json]     环境自检（排障用）；--json 只输出插件清单（机器可读）")
+    println("  cj-tauri doctor            环境自检逐行给结论（每条自带「缺了就怎么办」）")
     println("  cj-tauri help              显示本帮助")
     println("")
     println("环境变量:")
@@ -45,28 +48,48 @@ main(args: Array<String>): Int64 {
     if (sub == "create") {
         var name = ""
         var tpl = "app"
+        var bundle = ""
+        var label = ""
         var i = 1
         while (i < args.size) {
             let a = args[i]
             if (a == "--template" || a == "-t") {
                 if (i + 1 >= args.size) {
-                    eprintln("用法: cj-tauri create <项目名> [--template app|vue|react]")
+                    eprintln("用法: cj-tauri create <项目名> [--template app|vue|react|ohos]")
                     return 1
                 }
                 tpl = args[i + 1]
                 i = i + 2
                 continue
             }
+            if (a == "--bundle") {
+                if (i + 1 >= args.size) {
+                    eprintln("用法: cj-tauri create <项目名> --template ohos [--bundle <bundleName>]")
+                    return 1
+                }
+                bundle = args[i + 1]
+                i = i + 2
+                continue
+            }
+            if (a == "--label") {
+                if (i + 1 >= args.size) {
+                    eprintln("用法: cj-tauri create <项目名> --template ohos [--label <应用名>]")
+                    return 1
+                }
+                label = args[i + 1]
+                i = i + 2
+                continue
+            }
             if (name.size == 0) {
                 name = a
             }
             i = i + 1
         }
         if (name.size == 0) {
-            eprintln("用法: cj-tauri create <项目名> [--template app|vue|react]")
+            eprintln("用法: cj-tauri create <项目名> [--template app|vue|react|ohos]")
             return 1
         }
-        return cmdCreate(name, tpl)
+        return cmdCreate(name, tpl, bundle, label)
     }
     if (sub == "dev") {
         return cmdDev()
@@ -88,6 +111,9 @@ main(args: Array<String>): Int64 {
         }
         return cmdInfo(asJson)
     }
+    if (sub == "doctor") {
+        return cmdDoctor()
+    }
     eprintln("未知子命令: ${sub}")
     println("")
     usage()

package/cli/src/project.cj

@@ -10,7 +10,7 @@ import std.collection.*
 
 /** CLI 版本：须与 cli/cjpm.toml 的 version、CHANGELOG 顶部版本一致（scripts/check-version.sh 校验） */
 func cliVersion(): String {
-    return "0.8.0"
+    return "1.1.1"
 }
 
 /** 一次命令所需的路径上下文 */
@@ -443,7 +443,56 @@ func runProject(c: AppContext): Int64 {
     return code
 }
 
+/** 某个目录下是不是鸿蒙脚手架工程（判据：build-hap.sh + entry/cjpm.toml 同时在） */
+func isOhosProjectAt(dir: String): Bool {
+    return exists(joinPath(dir, "build-hap.sh")) && exists(joinPath(joinPath(dir, "entry"), "cjpm.toml"))
+}
+
+/**
+ * 当前工作目录属于哪个鸿蒙工程（也认「站在 entry/ 里」这种跑法）
+ *
+ * 不能复用 `findProjectRoot`：鸿蒙工程根**没有** cjpm.toml（那份在 entry/ 下），
+ * 按「向上找 cjpm.toml」会在工程内一路找不到、反而跑到外面某个仓颉工程上去。
+ */
+func findOhosProjectRoot(): Option<String> {
+    let cur = stripTrailingSep(currentDir())
+    if (isOhosProjectAt(cur)) {
+        return Some(cur)
+    }
+    if (let Some(p) <- parentDir(cur)) {
+        if (isOhosProjectAt(p)) {
+            return Some(p)
+        }
+    }
+    return None
+}
+
+/**
+ * 鸿蒙工程：构建入口就是工程自带的 `build-hap.sh`
+ *
+ * 跑它而不是自己拼 hvigor 命令：DevEco 探测、cjc/opt 同代、stdx 联接、`--no-daemon`
+ * 这些坑全在脚本里（见模板 build-hap.sh 的注释），CLI 只负责传参。
+ * `--install` 走 `run`：编完装到设备并 `aa start`。
+ */
+func buildOhos(root: String, install: Bool): Int64 {
+    var argv = ArrayList<String>()
+    argv.add("build-hap.sh")
+    if (install) {
+        argv.add("--install")
+    }
+    println("[cj-tauri] 鸿蒙工程：bash build-hap.sh${if (install) { " --install" } else { "" }}（${root}）")
+    let code = execute("bash", argv.toArray(), workingDirectory: Path(root))
+    if (code != 0) {
+        eprintln("[cj-tauri] 构建失败（exit=${code}）")
+        eprintln("          日志: ${joinPath(root, ".buildlog")}/last-build.log")
+    }
+    return code
+}
+
 func cmdBuild(): Int64 {
+    if (let Some(root) <- findOhosProjectRoot()) {
+        return buildOhos(root, false)
+    }
     if (let Some(c) <- loadContext()) {
         if (buildProject(c, true)) {
             return 0
@@ -454,6 +503,12 @@ func cmdBuild(): Int64 {
 }
 
 func cmdDev(): Int64 {
+    if (let Some(root) <- findOhosProjectRoot()) {
+        // 鸿蒙没有「dev server 接管页面」这条路：页面是 hap 里的 rawfile，
+        // 改一次要重编一次；dev 就等同于 build（再加上装到设备更常见，留给 run）。
+        println("[cj-tauri] 鸿蒙工程：dev 等同于 build（页面在 hap 的 rawfile 里，没有 dev server）")
+        return buildOhos(root, false)
+    }
     if (let Some(c) <- loadContext()) {
         // 有 ui/package.json 才走 Node 路径：dev 模式页面来自 dev server，不必先打发布包
         var withUi = true
@@ -475,6 +530,9 @@ func cmdDev(): Int64 {
 }
 
 func cmdRun(): Int64 {
+    if (let Some(root) <- findOhosProjectRoot()) {
+        return buildOhos(root, true)
+    }
     if (let Some(c) <- loadContext()) {
         return runProject(c)
     }