@oniroproject/core 0.6.1 → 0.7.0

package/dist/index.js

@@ -15,6 +15,15 @@ var consoleLogger = {
   warn: (m) => console.warn(m),
   error: (m) => console.error(m)
 };
+function scopedLogger(logger, scope) {
+  const prefix = `[${scope}] `;
+  return {
+    debug: (m) => logger.debug(prefix + m),
+    info: (m) => logger.info(prefix + m),
+    warn: (m) => logger.warn(prefix + m),
+    error: (m) => logger.error(prefix + m)
+  };
+}
 
 // src/ports/progress.ts
 var noopProgress = {
@@ -119,6 +128,19 @@ var CancelledError = class extends OniroError {
     this.name = "CancelledError";
   }
 };
+var CommandFailedError = class extends OniroError {
+  constructor(command, exitCode, stderr) {
+    super(`Command failed (exit ${exitCode}): ${command}${stderr ? `
+${stderr}` : ""}`);
+    this.command = command;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "CommandFailedError";
+  }
+  command;
+  exitCode;
+  stderr;
+};
 
 // src/ports/context.ts
 function defaultContext(overrides = {}) {
@@ -130,15 +152,16 @@ function defaultContext(overrides = {}) {
 
 // src/sdk/constants.ts
 var ALL_SDKS = [
-  { version: "4.0", api: "10" },
-  { version: "4.1", api: "11" },
-  { version: "5.0.0", api: "12" },
-  { version: "5.0.1", api: "13" },
-  { version: "5.0.2", api: "14" },
-  { version: "5.0.3", api: "15" },
-  { version: "5.1.0", api: "18" },
-  { version: "6.0", api: "20" },
-  { version: "6.1", api: "23" }
+  { version: "4.0", api: "10", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "4.1", api: "11", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.0.0", api: "12", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "5.0.1", api: "13", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "5.0.2", api: "14", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.0.3", api: "15", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.1.0", api: "18", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.1.1", api: "19", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "6.0", api: "20", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "6.1", api: "23", tarballStrip: { linuxWindows: 0, darwin: 3 } }
 ];
 var OHOS_URL_BASE = "https://repo.huaweicloud.com/openharmony/os";
 
@@ -154,19 +177,18 @@ function getOsFolder() {
 function getSdkFilename(version) {
   const platform6 = os2.platform();
   const v = version ?? ALL_SDKS[ALL_SDKS.length - 1].version;
+  const strips = ALL_SDKS.find((r) => r.version === v)?.tarballStrip ?? { linuxWindows: 1, darwin: 3 };
   if (platform6 === "linux") {
-    const strip = v === "5.0.0" || v === "5.0.1" || v === "6.0" || v === "6.1" ? 0 : 1;
-    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "linux", strip };
+    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "linux", strip: strips.linuxWindows };
   }
   if (platform6 === "darwin") {
     if (os2.arch() === "arm64") {
-      return { filename: "L2-SDK-MAC-M1-PUBLIC.tar.gz", osFolder: "darwin", strip: 3 };
+      return { filename: "L2-SDK-MAC-M1-PUBLIC.tar.gz", osFolder: "darwin", strip: strips.darwin };
     }
-    return { filename: "ohos-sdk-mac-public.tar.gz", osFolder: "darwin", strip: 3 };
+    return { filename: "ohos-sdk-mac-public.tar.gz", osFolder: "darwin", strip: strips.darwin };
   }
   if (platform6 === "win32") {
-    const strip = v === "5.0.0" || v === "5.0.1" || v === "6.0" || v === "6.1" ? 0 : 1;
-    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "windows", strip };
+    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "windows", strip: strips.linuxWindows };
   }
   throw new UnsupportedPlatformError(platform6);
 }
@@ -193,17 +215,20 @@ function pickExisting(candidates) {
   }
   return candidates[0];
 }
-function getCmdToolsBin(config) {
+function getCmdToolsBin(config, name = "ohpm") {
   const binDir = path2.join(getCmdToolsPath(config), "bin");
   if (os3.platform() === "win32") {
     return pickExisting([
-      path2.join(binDir, "ohpm.exe"),
-      path2.join(binDir, "ohpm.cmd"),
-      path2.join(binDir, "ohpm.bat"),
-      path2.join(binDir, "ohpm")
+      path2.join(binDir, `${name}.exe`),
+      path2.join(binDir, `${name}.cmd`),
+      path2.join(binDir, `${name}.bat`),
+      path2.join(binDir, name)
     ]);
   }
-  return path2.join(binDir, "ohpm");
+  return path2.join(binDir, name);
+}
+function getOhpmPath(config) {
+  return getCmdToolsBin(config, "ohpm");
 }
 function getHdcPath(config) {
   const base = path2.join(getCmdToolsPath(config), "sdk", "default", "openharmony", "toolchains");
@@ -218,15 +243,20 @@ function getHdcPath(config) {
   return path2.join(base, "hdc");
 }
 function getHvigorwPath(config, projectDir) {
-  const cmdToolsBin = path2.join(getCmdToolsPath(config), "bin");
-  return pickExisting([
+  const local = pickExisting([
     path2.join(projectDir, "hvigorw"),
     path2.join(projectDir, "hvigorw.bat"),
-    path2.join(projectDir, "hvigorw.cmd"),
-    path2.join(cmdToolsBin, "hvigorw"),
-    path2.join(cmdToolsBin, "hvigorw.bat"),
-    path2.join(cmdToolsBin, "hvigorw.cmd")
+    path2.join(projectDir, "hvigorw.cmd")
   ]);
+  if (fs.existsSync(local) && isProjectLocalHvigorwWorking(projectDir)) {
+    return local;
+  }
+  return getCmdToolsBin(config, "hvigorw");
+}
+function isProjectLocalHvigorwWorking(projectDir) {
+  const wrapper = path2.join(projectDir, "hvigor", "hvigor-wrapper.js");
+  const nodeModules = path2.join(projectDir, "hvigor", "node_modules");
+  return fs.existsSync(wrapper) && fs.existsSync(nodeModules);
 }
 
 // src/sdk/detectProjectSdk.ts
@@ -482,22 +512,37 @@ function removeSdk(config, api) {
 }
 
 // src/sdk/install.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as os5 from "os";
 import * as path7 from "path";
+
+// src/sdk/move.ts
+import * as fs7 from "fs";
+function movePath(src, dest) {
+  try {
+    fs7.renameSync(src, dest);
+  } catch (err) {
+    if (err.code !== "EXDEV") throw err;
+    fs7.cpSync(src, dest, { recursive: true });
+    fs7.rmSync(src, { recursive: true, force: true });
+  }
+}
+
+// src/sdk/install.ts
 async function downloadAndInstallSdk(opts) {
   const { config, version, api, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const { filename, osFolder, strip } = getSdkFilename(version);
-  const downloadUrl = `${OHOS_URL_BASE}/${version}-Release/${filename}`;
+  const urlBase = config.get("sdkUrlBase", OHOS_URL_BASE);
+  const downloadUrl = `${urlBase}/${version}-Release/${filename}`;
   const sha256Url = `${downloadUrl}.sha256`;
-  const tmpDir = fs7.mkdtempSync(path7.join(os5.tmpdir(), "oniro-sdk-"));
+  const tmpDir = fs8.mkdtempSync(path7.join(os5.tmpdir(), "oniro-sdk-"));
   const tarPath = path7.join(tmpDir, filename);
   const sha256Path = path7.join(tmpDir, `${filename}.sha256`);
   const extractDir = path7.join(tmpDir, "extract");
-  fs7.mkdirSync(extractDir);
+  fs8.mkdirSync(extractDir);
   const sdkInstallDir = path7.join(getSdkRootDir(config), osFolder, api);
-  fs7.mkdirSync(path7.dirname(sdkInstallDir), { recursive: true });
+  fs8.mkdirSync(path7.dirname(sdkInstallDir), { recursive: true });
   const checkCancelled = () => {
     if (abortSignal?.aborted) throw new CancelledError();
   };
@@ -515,12 +560,12 @@ async function downloadAndInstallSdk(opts) {
     progress?.report({ message: "Extracting SDK (this may take a while)...", increment: 10 });
     checkCancelled();
     const osContentPath = path7.join(extractDir, osFolder);
-    if (!fs7.existsSync(osContentPath)) {
+    if (!fs8.existsSync(osContentPath)) {
       throw new OniroError(
         `Expected folder '${osFolder}' not found in extracted SDK. Tarball layout may have changed.`
       );
     }
-    const zipFiles = fs7.readdirSync(osContentPath).filter((n2) => n2.endsWith(".zip"));
+    const zipFiles = fs8.readdirSync(osContentPath).filter((n2) => n2.endsWith(".zip"));
     const componentsStart = 60;
     const componentsBudget = 35;
     const n = zipFiles.length;
@@ -540,26 +585,26 @@ async function downloadAndInstallSdk(opts) {
       if (rem > 0) rem--;
       await extractZipWithProgress({ zipPath, dest: osContentPath, progress, start: cursor, range: thisBudget, logger });
       cursor += thisBudget;
-      fs7.unlinkSync(zipPath);
+      fs8.unlinkSync(zipPath);
     }
     progress?.report({ message: "Finalizing installation...", increment: 0 });
-    if (fs7.existsSync(sdkInstallDir)) {
-      fs7.rmSync(sdkInstallDir, { recursive: true, force: true });
+    if (fs8.existsSync(sdkInstallDir)) {
+      fs8.rmSync(sdkInstallDir, { recursive: true, force: true });
     }
-    fs7.renameSync(osContentPath, sdkInstallDir);
+    movePath(osContentPath, sdkInstallDir);
     progress?.report({ message: "Finalizing installation...", increment: 3 });
     progress?.report({ message: "Cleaning up...", increment: 0 });
-    fs7.rmSync(tmpDir, { recursive: true, force: true });
+    fs8.rmSync(tmpDir, { recursive: true, force: true });
     progress?.report({ message: "Cleaning up...", increment: 2 });
   } catch (err) {
     logger.error(`SDK install failed: ${err instanceof Error ? err.message : String(err)}`);
-    fs7.rmSync(tmpDir, { recursive: true, force: true });
+    fs8.rmSync(tmpDir, { recursive: true, force: true });
     throw err;
   }
 }
 
 // src/cmdTools/install.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as os6 from "os";
 import * as path8 from "path";
 import { execFileSync } from "child_process";
@@ -594,11 +639,11 @@ function findCmdToolsSourceDir(extractPath) {
     path8.join(extractPath, "commandline-tools")
   ];
   for (const c of known) {
-    if (fs8.existsSync(c)) return c;
+    if (fs9.existsSync(c)) return c;
   }
-  const entries = fs8.readdirSync(extractPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path8.join(extractPath, e.name));
+  const entries = fs9.readdirSync(extractPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path8.join(extractPath, e.name));
   for (const dir of entries) {
-    if (fs8.existsSync(path8.join(dir, "bin"))) return dir;
+    if (fs9.existsSync(path8.join(dir, "bin"))) return dir;
   }
   throw new OniroError("Could not locate command line tools folder in the extracted archive.");
 }
@@ -606,7 +651,7 @@ async function installCmdTools(opts) {
   const { config, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const CMD_PATH = getCmdToolsPath(config);
-  const tmpDir = fs8.mkdtempSync(path8.join(os6.tmpdir(), "oniro-cmdtools-"));
+  const tmpDir = fs9.mkdtempSync(path8.join(os6.tmpdir(), "oniro-cmdtools-"));
   const zipPath = opts.localZipPath ?? path8.join(tmpDir, "oh-command-line-tools.zip");
   const extractPath = path8.join(tmpDir, "oh-command-line-tools");
   try {
@@ -617,42 +662,42 @@ async function installCmdTools(opts) {
     }
     progress?.report({ message: "Extracting tools...", increment: 0 });
     await extractZipWithProgress({ zipPath, dest: extractPath, progress, start: 50, range: 45, logger });
-    fs8.mkdirSync(CMD_PATH, { recursive: true });
+    fs9.mkdirSync(CMD_PATH, { recursive: true });
     const srcDir = findCmdToolsSourceDir(extractPath);
-    for (const entry of fs8.readdirSync(srcDir)) {
+    for (const entry of fs9.readdirSync(srcDir)) {
       const src = path8.join(srcDir, entry);
       const dest = path8.join(CMD_PATH, entry);
-      if (fs8.statSync(src).isDirectory()) {
-        if (fs8.existsSync(dest)) fs8.rmSync(dest, { recursive: true, force: true });
-        fs8.renameSync(src, dest);
+      if (fs9.statSync(src).isDirectory()) {
+        if (fs9.existsSync(dest)) fs9.rmSync(dest, { recursive: true, force: true });
+        movePath(src, dest);
       } else {
-        fs8.copyFileSync(src, dest);
+        fs9.copyFileSync(src, dest);
       }
     }
     const binDir = path8.join(CMD_PATH, "bin");
-    if (fs8.existsSync(binDir) && os6.platform() !== "win32") {
-      for (const file of fs8.readdirSync(binDir)) {
-        fs8.chmodSync(path8.join(binDir, file), 493);
+    if (fs9.existsSync(binDir) && os6.platform() !== "win32") {
+      for (const file of fs9.readdirSync(binDir)) {
+        fs9.chmodSync(path8.join(binDir, file), 493);
       }
     }
     progress?.report({ message: "Finalizing installation...", increment: 5 });
     progress?.report({ message: "Cleaning up...", increment: 0 });
   } finally {
-    fs8.rmSync(tmpDir, { recursive: true, force: true });
+    fs9.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function getCmdToolsStatus(config) {
   const cmdPath = getCmdToolsPath(config);
   const binDir = path8.join(cmdPath, "bin");
   const candidates = os6.platform() === "win32" ? ["ohpm.exe", "ohpm.cmd", "ohpm.bat", "ohpm"] : ["ohpm"];
-  const bin = candidates.map((c) => path8.join(binDir, c)).find((p) => fs8.existsSync(p));
+  const bin = candidates.map((c) => path8.join(binDir, c)).find((p) => fs9.existsSync(p));
   if (!bin) {
     return { installed: false, status: "Not installed" };
   }
   try {
     const versionFile = path8.join(cmdPath, "version.txt");
-    if (fs8.existsSync(versionFile)) {
-      const content = fs8.readFileSync(versionFile, "utf8");
+    if (fs9.existsSync(versionFile)) {
+      const content = fs9.readFileSync(versionFile, "utf8");
       for (const line of content.split(/\r?\n/)) {
         const m = line.match(/^\s*#\s*Version:\s*(.+)$/);
         if (m?.[1]) return { installed: true, status: `Installed (${m[1].trim()})` };
@@ -672,13 +717,13 @@ function isCmdToolsInstalled(config) {
 }
 function removeCmdTools(config) {
   const cmdPath = getCmdToolsPath(config);
-  if (fs8.existsSync(cmdPath)) {
-    fs8.rmSync(cmdPath, { recursive: true, force: true });
+  if (fs9.existsSync(cmdPath)) {
+    fs9.rmSync(cmdPath, { recursive: true, force: true });
   }
 }
 
 // src/sign/encryptKey.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path9 from "path";
 import * as crypto2 from "crypto";
 var DAEMON_ROOT_KEY_COMPONENT_LENGTH = 16;
@@ -752,8 +797,8 @@ function createAndStoreKey(dir, keyLength) {
   const key = crypto2.randomBytes(keyLength);
   const hash = crypto2.createHash("sha256").update(key).digest("hex");
   const filePath = path9.join(dir, hash);
-  fs9.writeFileSync(filePath, key);
-  fs9.chmodSync(filePath, KEY_FILE_PERMISSIONS);
+  fs10.writeFileSync(filePath, key);
+  fs10.chmodSync(filePath, KEY_FILE_PERMISSIONS);
   return key;
 }
 function createAndStoreEnKey(rootKey, ceDir) {
@@ -761,23 +806,23 @@ function createAndStoreEnKey(rootKey, ceDir) {
   const encrypted = encrypt(rootKey, workKey);
   const hash = crypto2.createHash("sha256").update(encrypted).digest("hex");
   const filePath = path9.join(ceDir, hash);
-  fs9.writeFileSync(filePath, encrypted);
-  fs9.chmodSync(filePath, KEY_FILE_PERMISSIONS);
+  fs10.writeFileSync(filePath, encrypted);
+  fs10.chmodSync(filePath, KEY_FILE_PERMISSIONS);
 }
 function createMaterial(materialPath) {
-  fs9.mkdirSync(materialPath, { recursive: true });
-  fs9.chmodSync(materialPath, KEY_FILE_DIRECTORY_PERMISSIONS);
+  fs10.mkdirSync(materialPath, { recursive: true });
+  fs10.chmodSync(materialPath, KEY_FILE_DIRECTORY_PERMISSIONS);
   const fdDir = path9.join(materialPath, "fd");
   const acDir = path9.join(materialPath, "ac");
   const ceDir = path9.join(materialPath, "ce");
-  fs9.mkdirSync(fdDir, { recursive: true });
-  fs9.mkdirSync(acDir, { recursive: true });
-  fs9.mkdirSync(ceDir, { recursive: true });
+  fs10.mkdirSync(fdDir, { recursive: true });
+  fs10.mkdirSync(acDir, { recursive: true });
+  fs10.mkdirSync(ceDir, { recursive: true });
   const fdSubDirs = ["0", "1", "2"];
   const fdComponents = [];
   for (const sub of fdSubDirs) {
     const subDir = path9.join(fdDir, sub);
-    fs9.mkdirSync(subDir, { recursive: true });
+    fs10.mkdirSync(subDir, { recursive: true });
     const comp = createAndStoreKey(subDir, DAEMON_ROOT_KEY_COMPONENT_LENGTH);
     fdComponents.push(comp);
   }
@@ -786,17 +831,17 @@ function createMaterial(materialPath) {
   createAndStoreEnKey(rootKey, ceDir);
 }
 function readSingleFile(dir) {
-  if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
+  if (!fs10.existsSync(dir) || !fs10.statSync(dir).isDirectory()) {
     throw new Error(`Missing signing material directory: ${dir}`);
   }
-  const files = fs9.readdirSync(dir).filter((f) => f !== ".DS_Store");
+  const files = fs10.readdirSync(dir).filter((f) => f !== ".DS_Store");
   if (files.length !== 1) {
     throw new Error(`Signing material in ${dir} is illegal (expected exactly one file).`);
   }
-  return fs9.readFileSync(path9.join(dir, files[0]));
+  return fs10.readFileSync(path9.join(dir, files[0]));
 }
 function getKey(materialPath) {
-  if (!fs9.existsSync(materialPath) || !fs9.statSync(materialPath).isDirectory()) {
+  if (!fs10.existsSync(materialPath) || !fs10.statSync(materialPath).isDirectory()) {
     throw new Error("Material directory does not exist.");
   }
   const fdDir = path9.join(materialPath, "fd");
@@ -818,41 +863,120 @@ function decryptPwd(encryptedHex, materialPath) {
 }
 
 // src/sign/generateSigningConfigs.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path10 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import JSON52 from "json5";
+
+// src/sign/applicationCert.ts
+var OPEN_HARMONY_APPLICATION_CERT = `-----BEGIN CERTIFICATE-----
+MIICRDCCAcmgAwIBAgIED+E4izAMBggqhkjOPQQDAwUAMGgxCzAJBgNVBAYTAkNO
+MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh
+bTEoMCYGA1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTAeFw0y
+MTAyMDIxMjE0MThaFw00OTEyMzExMjE0MThaMGgxCzAJBgNVBAYTAkNOMRQwEgYD
+VQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVhbTEoMCYG
+A1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABE023XmRaw2DnO8NSsb+KG/uY0FtS3u5LQucdr3qWVnRW5ui
+QIL6ttNZBEeLTUeYcJZCpayg9Llf+1SmDA7dY4iP2EcRo4UN3rilovtfFfsmH4ty
+3SApHVFzWUl+NwdH8KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AQYwHQYDVR0OBBYEFBc6EKGrGXzlAE+s0Zgnsphadw7NMAwGCCqGSM49BAMDBQAD
+ZwAwZAIwd1p3JzHN93eoPped1li0j64npgqNzwy4OrkehYAqNXpcpaEcLZ7UxW8E
+I2lZJ3SbAjAkqySHb12sIwdSFKSN9KCMMEo/eUT5dUXlcKR2nZz0MJdxT5F51qcX
+1CumzkcYhgU=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICYTCCAeWgAwIBAgIEHmXAPTAMBggqhkjOPQQDAwUAMGgxCzAJBgNVBAYTAkNO
+MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh
+bTEoMCYGA1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTAeFw0y
+MTAyMDIxMjE1MzJaFw00OTEyMzExMjE1MzJaMGMxCzAJBgNVBAYTAkNOMRQwEgYD
+VQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVhbTEjMCEG
+A1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwdjAQBgcqhkjOPQIBBgUr
+gQQAIgNiAAQhnu7Hna8XNa2KyqRf5+lBJScE4xqf89N0g0OuqAb2re8nGsvWkw26
+uDekfnBYicd+G3Cydqa2zFIwV7Talyg2ULW3r8KbGpyl84mJEPPRmCGJ+H9gtCsf
++OrJ4Y76LVWjYzBhMB8GA1UdIwQYMBaAFBc6EKGrGXzlAE+s0Zgnsphadw7NMA8G
+A1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTbhrciFtUL
+oUu33SV7ufEFfaItRzAMBggqhkjOPQQDAwUAA2gAMGUCMG3cXjiDmXTvf7D4Omhf
+qcc2nuO+EMfWE+N9ZhBP5UhV34mAGWi3SfLU6rcV0urWEQIxAMYIb3epOnKhUrcm
+Lfu1WKzFlpYQwmw73RaCHP2I3k6NcuWOYeNwWXSNZ8o0nzvaLg==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO
+MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh
+bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy
+MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML
+T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT
+H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq
+hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG
+JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci
+FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl
+cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps
+LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o
+zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/
+-----END CERTIFICATE-----
+`;
+
+// src/sign/generateSigningConfigs.ts
 var APL_VALUES = ["normal", "system_basic", "system_core"];
 var APP_FEATURE_VALUES = ["hos_normal_app", "hos_system_app"];
-function copyFilesToProject(projectDir, paths, logger) {
+var DEFAULT_PASSWORDS = { store: "123456", key: "123456" };
+function pickSigningKind(apl) {
+  return apl === "normal" ? "profile-release" : "application-release";
+}
+var SIGNING_KIND_CONFIG = {
+  "profile-release": {
+    hapKeyAlias: "openharmony application profile release",
+    certBasename: "OpenHarmonyProfileRelease.pem"
+  },
+  "application-release": {
+    hapKeyAlias: "OpenHarmony Application Release",
+    certBasename: "OpenHarmonyApplication.cer"
+  }
+};
+function copyFilesToProject(projectDir, paths, kind, logger, applicationCertPath) {
   logger.info("[sign] Copying signing material into project...");
   const signaturesDir = path10.join(projectDir, "signatures");
-  fs10.mkdirSync(signaturesDir, { recursive: true });
-  fs10.copyFileSync(paths.keystore, path10.join(signaturesDir, "OpenHarmony.p12"));
-  fs10.copyFileSync(paths.profileCert, path10.join(signaturesDir, "OpenHarmonyProfileRelease.pem"));
-  fs10.copyFileSync(paths.unsignedProfileTemplate, path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json"));
+  fs11.mkdirSync(signaturesDir, { recursive: true });
+  fs11.copyFileSync(paths.keystore, path10.join(signaturesDir, "OpenHarmony.p12"));
+  fs11.copyFileSync(paths.profileCert, path10.join(signaturesDir, "OpenHarmonyProfileRelease.pem"));
+  fs11.copyFileSync(paths.unsignedProfileTemplate, path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json"));
+  if (kind === "application-release") {
+    const dest = path10.join(signaturesDir, "OpenHarmonyApplication.cer");
+    if (applicationCertPath) {
+      fs11.copyFileSync(applicationCertPath, dest);
+    } else {
+      fs11.writeFileSync(dest, OPEN_HARMONY_APPLICATION_CERT);
+    }
+  }
 }
 function resolveAppFeature(apl, override) {
   if (override) return override;
   return apl === "normal" ? "hos_normal_app" : "hos_system_app";
 }
-function modifyProfileTemplate(projectDir, apl, appFeature, logger) {
-  logger.info(`[sign] Modifying profile template (apl=${apl}, app-feature=${appFeature})...`);
+function extractLeafCertificate(chainPath) {
+  const certContent = fs11.readFileSync(chainPath, "utf-8");
+  const parts = certContent.split("-----END CERTIFICATE-----");
+  if (parts.length < 3) {
+    throw new OniroError(`${chainPath} does not contain enough certificates.`);
+  }
+  return parts[2].trim() + "\n-----END CERTIFICATE-----\n";
+}
+function modifyProfileTemplate(projectDir, apl, appFeature, logger, options = {}) {
+  const kind = options.kind ?? pickSigningKind(apl);
+  logger.info(`[sign] Modifying profile template (apl=${apl}, app-feature=${appFeature}, kind=${kind})...`);
   const appJsonPath = path10.join(projectDir, "AppScope/app.json5");
   const profileTemplatePath = path10.join(projectDir, "signatures/UnsgnedReleasedProfileTemplate.json");
-  const profileCertFilePath = path10.join(projectDir, "signatures/OpenHarmonyProfileRelease.pem");
-  if (!fs10.existsSync(appJsonPath)) {
+  if (!fs11.existsSync(appJsonPath)) {
     throw new OniroError(`${appJsonPath} does not exist.`);
   }
   let appJson;
   try {
-    appJson = JSON52.parse(fs10.readFileSync(appJsonPath, "utf-8"));
+    appJson = JSON52.parse(fs11.readFileSync(appJsonPath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${appJsonPath}: ${e.message}`, e);
   }
   let profileTemplate;
   try {
-    profileTemplate = JSON.parse(fs10.readFileSync(profileTemplatePath, "utf-8"));
+    profileTemplate = JSON.parse(fs11.readFileSync(profileTemplatePath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${profileTemplatePath}: ${e.message}`, e);
   }
@@ -865,16 +989,19 @@ function modifyProfileTemplate(projectDir, apl, appFeature, logger) {
   profileTemplate["bundle-info"]["bundle-name"] = appJson.app.bundleName;
   profileTemplate["bundle-info"]["apl"] = apl;
   profileTemplate["bundle-info"]["app-feature"] = appFeature;
-  const certContent = fs10.readFileSync(profileCertFilePath, "utf-8");
-  const certs = certContent.split("-----END CERTIFICATE-----");
-  if (certs.length < 3) {
-    throw new OniroError(`${profileCertFilePath} does not contain enough certificates.`);
+  const distCertChainPath = path10.join(
+    projectDir,
+    "signatures",
+    SIGNING_KIND_CONFIG[kind].certBasename
+  );
+  profileTemplate["bundle-info"]["distribution-certificate"] = extractLeafCertificate(distCertChainPath);
+  if (options.acls !== void 0) {
+    profileTemplate.acls = profileTemplate.acls ?? {};
+    profileTemplate.acls["allowed-acls"] = options.acls;
   }
-  const thirdCert = certs[2].trim() + "\n-----END CERTIFICATE-----\n";
-  profileTemplate["bundle-info"]["distribution-certificate"] = thirdCert;
-  fs10.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
+  fs11.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
 }
-function generateP7bFile(projectDir, paths, logger) {
+function generateP7bFile(projectDir, paths, logger, passwords) {
   logger.info("[sign] Generating P7b profile via hap-sign-tool...");
   const signaturesDir = path10.join(projectDir, "signatures");
   const profileTemplatePath = path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json");
@@ -898,9 +1025,9 @@ function generateP7bFile(projectDir, paths, logger) {
     "-outFile",
     outputProfilePath,
     "-keyPwd",
-    "123456",
+    passwords.key,
     "-keystorePwd",
-    "123456"
+    passwords.store
   ];
   try {
     execFileSync2("java", args, { stdio: "inherit" });
@@ -911,42 +1038,63 @@ function generateP7bFile(projectDir, paths, logger) {
     );
   }
 }
-function updateBuildProfile(projectDir, logger) {
+function detectSigningConfigNames(projectDir) {
+  const buildProfilePath = path10.join(projectDir, "build-profile.json5");
+  if (!fs11.existsSync(buildProfilePath)) return ["default"];
+  let parsed;
+  try {
+    parsed = JSON52.parse(fs11.readFileSync(buildProfilePath, "utf-8"));
+  } catch {
+    return ["default"];
+  }
+  const products = parsed.app?.products;
+  if (!Array.isArray(products) || products.length === 0) return ["default"];
+  const names = [];
+  for (const product of products) {
+    const name = product.signingConfig;
+    if (typeof name === "string" && name.length > 0 && !names.includes(name)) {
+      names.push(name);
+    }
+  }
+  return names.length > 0 ? names : ["default"];
+}
+function updateBuildProfile(projectDir, kind, logger, passwords) {
   logger.info("[sign] Writing signing configs into build-profile.json5...");
   const materialDir = path10.join(projectDir, "signatures", "material");
   const buildProfilePath = path10.join(projectDir, "build-profile.json5");
-  const encryptedStorePassword = encryptPwd("123456", materialDir);
-  const encryptedKeyPassword = encryptPwd("123456", materialDir);
+  const encryptedStorePassword = encryptPwd(passwords.store, materialDir);
+  const encryptedKeyPassword = encryptPwd(passwords.key, materialDir);
   let buildProfile = { app: {} };
-  if (fs10.existsSync(buildProfilePath)) {
+  if (fs11.existsSync(buildProfilePath)) {
     try {
-      buildProfile = JSON52.parse(fs10.readFileSync(buildProfilePath, "utf-8"));
+      buildProfile = JSON52.parse(fs11.readFileSync(buildProfilePath, "utf-8"));
     } catch (e) {
       throw new OniroError(`Error parsing ${buildProfilePath}: ${e.message}`, e);
     }
   }
+  const { hapKeyAlias, certBasename } = SIGNING_KIND_CONFIG[kind];
+  const configNames = detectSigningConfigNames(projectDir);
+  logger.info(`[sign] Writing signingConfigs entries: ${configNames.join(", ")}`);
   buildProfile.app = buildProfile.app ?? {};
-  buildProfile.app.signingConfigs = [
-    {
-      name: "default",
-      material: {
-        certpath: "./signatures/OpenHarmonyProfileRelease.pem",
-        storePassword: encryptedStorePassword,
-        keyAlias: "openharmony application profile release",
-        keyPassword: encryptedKeyPassword,
-        profile: "./signatures/app1-profile.p7b",
-        signAlg: "SHA256withECDSA",
-        storeFile: "./signatures/OpenHarmony.p12"
-      }
+  buildProfile.app.signingConfigs = configNames.map((name) => ({
+    name,
+    material: {
+      certpath: `./signatures/${certBasename}`,
+      storePassword: encryptedStorePassword,
+      keyAlias: hapKeyAlias,
+      keyPassword: encryptedKeyPassword,
+      profile: "./signatures/app1-profile.p7b",
+      signAlg: "SHA256withECDSA",
+      storeFile: "./signatures/OpenHarmony.p12"
     }
-  ];
-  fs10.writeFileSync(buildProfilePath, JSON.stringify(buildProfile, null, 2));
+  }));
+  fs11.writeFileSync(buildProfilePath, JSON.stringify(buildProfile, null, 2));
 }
 function prepareMaterialDirectory(projectDir, logger) {
   logger.info("[sign] Generating fresh signing material...");
   const materialDir = path10.join(projectDir, "signatures", "material");
-  if (fs10.existsSync(materialDir)) {
-    fs10.rmSync(materialDir, { recursive: true, force: true });
+  if (fs11.existsSync(materialDir)) {
+    fs11.rmSync(materialDir, { recursive: true, force: true });
   }
   createMaterial(materialDir);
 }
@@ -970,7 +1118,7 @@ function generateSigningConfigs(options) {
     );
   }
   const sdkPath = path10.join(sdkHome, String(sdkVersion));
-  if (!fs10.existsSync(sdkPath)) {
+  if (!fs11.existsSync(sdkPath)) {
     throw new OniroError(`SDK path does not exist: ${sdkPath}`);
   }
   const paths = {
@@ -979,17 +1127,19 @@ function generateSigningConfigs(options) {
     profileCert: path10.join(sdkPath, "toolchains/lib/OpenHarmonyProfileRelease.pem"),
     unsignedProfileTemplate: path10.join(sdkPath, "toolchains/lib/UnsgnedReleasedProfileTemplate.json")
   };
+  const kind = pickSigningKind(apl);
+  const passwords = options.passwords ?? DEFAULT_PASSWORDS;
   logger.info("[sign] Starting signing configuration generation...");
-  copyFilesToProject(projectDir, paths, logger);
-  modifyProfileTemplate(projectDir, apl, appFeature, logger);
-  generateP7bFile(projectDir, paths, logger);
+  copyFilesToProject(projectDir, paths, kind, logger, options.applicationCertPath);
+  modifyProfileTemplate(projectDir, apl, appFeature, logger, { kind, acls: options.acls });
+  generateP7bFile(projectDir, paths, logger, passwords);
   prepareMaterialDirectory(projectDir, logger);
-  updateBuildProfile(projectDir, logger);
+  updateBuildProfile(projectDir, kind, logger, passwords);
   logger.info("[sign] Signing configuration generated successfully.");
 }
 
 // src/emulator/install.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as os7 from "os";
 import * as path11 from "path";
 async function installEmulator(opts) {
@@ -997,63 +1147,142 @@ async function installEmulator(opts) {
   const logger = opts.logger ?? noopLogger;
   const url = config.get("emulatorUrl", defaultPaths.emulatorUrl);
   const emulatorDir = getEmulatorDir(config);
-  const tmpDir = fs11.mkdtempSync(path11.join(os7.tmpdir(), "oniro-emulator-"));
+  const tmpDir = fs12.mkdtempSync(path11.join(os7.tmpdir(), "oniro-emulator-"));
   const tmpZip = path11.join(tmpDir, "oniro_emulator.zip");
   try {
-    fs11.mkdirSync(emulatorDir, { recursive: true });
+    fs12.mkdirSync(emulatorDir, { recursive: true });
     progress?.report({ message: "Downloading emulator...", increment: 0 });
     await downloadFile({ url, dest: tmpZip, progress, abortSignal, start: 0, range: 50 });
     progress?.report({ message: "Extracting emulator...", increment: 0 });
     await extractZipWithProgress({ zipPath: tmpZip, dest: emulatorDir, progress, start: 50, range: 45, logger });
     const runSh = path11.join(emulatorDir, "images", "run.sh");
-    if (fs11.existsSync(runSh)) {
-      fs11.chmodSync(runSh, 493);
+    if (fs12.existsSync(runSh)) {
+      fs12.chmodSync(runSh, 493);
     }
     progress?.report({ message: "Finalizing installation...", increment: 5 });
   } finally {
-    fs11.rmSync(tmpDir, { recursive: true, force: true });
+    fs12.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function isEmulatorInstalled(config) {
-  return fs11.existsSync(path11.join(getEmulatorDir(config), "images", "run.sh"));
+  const imagesDir = path11.join(getEmulatorDir(config), "images");
+  return fs12.existsSync(path11.join(imagesDir, "run.sh")) || fs12.existsSync(path11.join(imagesDir, "run.bat"));
 }
 function removeEmulator(config) {
   const emulatorDir = getEmulatorDir(config);
-  if (fs11.existsSync(emulatorDir)) {
-    fs11.rmSync(emulatorDir, { recursive: true, force: true });
+  if (fs12.existsSync(emulatorDir)) {
+    fs12.rmSync(emulatorDir, { recursive: true, force: true });
   }
 }
 
 // src/emulator/lifecycle.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os8 from "os";
 import * as path12 from "path";
-import { exec, spawn } from "child_process";
-var PID_FILE = path12.join(os8.tmpdir(), "oniro_emulator.pid");
-function execPromise(cmd, cwd, logger) {
+import { spawn as spawn2 } from "child_process";
+
+// src/hdc/exec.ts
+import { spawn } from "child_process";
+function runProcess(opts) {
+  const { command, args, cwd, env, onOutput } = opts;
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const { abortSignal } = opts;
   return new Promise((resolve2, reject) => {
-    exec(cmd, { cwd }, (error, stdout, stderr) => {
-      if (stdout?.trim()) logger.info(`[emulator] ${stdout.trim()}`);
-      if (stderr?.trim()) logger.warn(`[emulator] ${stderr.trim()}`);
-      if (error) {
-        logger.error(`[emulator] ${error.message}`);
-        reject(error);
-      } else {
-        resolve2();
+    if (abortSignal?.aborted) {
+      reject(new CancelledError(`Command aborted before start: ${command}`));
+      return;
+    }
+    const child = spawn(command, [...args], { cwd, env, shell: false });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      abortSignal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new CancelledError(`Command aborted: ${command} ${args.join(" ")}`));
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
       }
+    }, timeoutMs);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (d) => {
+      const s = d.toString();
+      stdout += s;
+      onOutput?.(s, "stdout");
+    });
+    child.stderr.on("data", (d) => {
+      const s = d.toString();
+      stderr += s;
+      onOutput?.(s, "stderr");
     });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new OniroError(`Failed to spawn ${command}: ${err.message}`, err));
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (timedOut) {
+        reject(
+          new OniroError(
+            `Command timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}` + (stderr.trim() ? `
+${stderr.trim()}` : "")
+          )
+        );
+        return;
+      }
+      resolve2({ code: code ?? -1, stdout, stderr });
+    });
+  });
+}
+function hdcExec(opts) {
+  const hdc = getHdcPath(opts.config);
+  const argv = opts.deviceSerial ? ["-t", opts.deviceSerial, ...opts.args] : [...opts.args];
+  return runProcess({
+    command: hdc,
+    args: argv,
+    timeoutMs: opts.timeoutMs,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
   });
 }
+function shell(opts) {
+  const { command, ...rest } = opts;
+  return hdcExec({ ...rest, args: ["shell", command] });
+}
+function ensureOk(result, command) {
+  if (result.code !== 0) {
+    throw new CommandFailedError(command, result.code, result.stderr.trim());
+  }
+  return result;
+}
+
+// src/emulator/lifecycle.ts
+var PID_FILE = path12.join(os8.tmpdir(), "oniro_emulator.pid");
 async function attemptHdcConnection(config, address = "127.0.0.1:55555", logger = noopLogger) {
-  const hdc = getHdcPath(config);
   try {
-    await execPromise(`"${hdc}" start -r`, void 0, logger);
-    await execPromise(`"${hdc}" tconn ${address}`, void 0, logger);
-    return await new Promise((resolve2) => {
-      exec(`"${hdc}" list targets`, (_error, stdout) => {
-        resolve2(stdout?.includes(address) ?? false);
-      });
-    });
+    await hdcExec({ config, args: ["start", "-r"], logger });
+    await hdcExec({ config, args: ["tconn", address], logger });
+    const targets = await hdcExec({ config, args: ["list", "targets"], logger });
+    return targets.stdout.includes(address);
   } catch (err) {
     logger.warn(`hdc connection attempt failed: ${err.message}`);
     return false;
@@ -1066,18 +1295,18 @@ function resolveLauncher(imagesPath, headless, connect) {
   if (headless) extra.push("--headless");
   if (connect) extra.push("--connect", connect);
   if (os8.platform() === "win32") {
-    if (fs12.existsSync(runBat)) {
+    if (fs13.existsSync(runBat)) {
       return { command: "cmd.exe", args: ["/c", runBat, ...extra], cwd: imagesPath };
     }
-    if (fs12.existsSync(runSh)) {
+    if (fs13.existsSync(runSh)) {
       return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
     }
     throw new OniroError(`No emulator launcher (run.bat or run.sh) found in ${imagesPath}.`);
   }
-  if (fs12.existsSync(runSh)) {
+  if (fs13.existsSync(runSh)) {
     return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
   }
-  if (fs12.existsSync(runBat)) {
+  if (fs13.existsSync(runBat)) {
     return { command: "bash", args: [runBat, ...extra], cwd: imagesPath };
   }
   throw new OniroError(`No emulator launcher (run.sh or run.bat) found in ${imagesPath}.`);
@@ -1085,9 +1314,9 @@ function resolveLauncher(imagesPath, headless, connect) {
 async function startEmulator(opts) {
   const { config } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (os8.platform() !== "win32" && fs12.existsSync(PID_FILE)) {
+  if (os8.platform() !== "win32" && fs13.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs12.readFileSync(PID_FILE, "utf8").trim());
+      const pid = Number(fs13.readFileSync(PID_FILE, "utf8").trim());
       if (Number.isFinite(pid) && pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1104,27 +1333,27 @@ async function startEmulator(opts) {
     }
   }
   const imagesPath = path12.join(getEmulatorDir(config), "images");
-  if (!fs12.existsSync(imagesPath)) {
+  if (!fs13.existsSync(imagesPath)) {
     throw new OniroError(`Emulator images directory not found at ${imagesPath}. Run \`oniro-app emulator install\` first.`);
   }
   const launcher = resolveLauncher(imagesPath, opts.headless === true, opts.connect);
   const logPath = opts.logFile ?? (os8.platform() === "win32" ? "NUL" : "/dev/null");
-  const logFd = fs12.openSync(logPath, "a");
+  const logFd = fs13.openSync(logPath, "a");
   let child;
   try {
-    child = spawn(launcher.command, [...launcher.args], {
+    child = spawn2(launcher.command, [...launcher.args], {
       cwd: launcher.cwd,
       detached: true,
       stdio: ["ignore", logFd, logFd],
       windowsHide: true
     });
   } finally {
-    fs12.closeSync(logFd);
+    fs13.closeSync(logFd);
   }
   if (!child.pid) {
     throw new OniroError(`Failed to spawn launcher (${launcher.command} ${launcher.args.join(" ")}).`);
   }
-  fs12.writeFileSync(PID_FILE, String(child.pid));
+  fs13.writeFileSync(PID_FILE, String(child.pid));
   child.unref();
   logger.info(`Emulator launched (PID ${child.pid}). Logs: ${logPath}`);
   const earlyExit = new Promise((resolve2) => {
@@ -1171,24 +1400,24 @@ ${tail}` : ""}`);
 }
 function readTail(filePath, bytes) {
   try {
-    const stat = fs12.statSync(filePath);
+    const stat = fs13.statSync(filePath);
     const start = Math.max(0, stat.size - bytes);
-    const fd = fs12.openSync(filePath, "r");
+    const fd = fs13.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(stat.size - start);
-      fs12.readSync(fd, buf, 0, buf.length, start);
+      fs13.readSync(fd, buf, 0, buf.length, start);
       return buf.toString("utf8");
     } finally {
-      fs12.closeSync(fd);
+      fs13.closeSync(fd);
     }
   } catch {
     return "";
   }
 }
 async function stopEmulator(logger = noopLogger) {
-  if (fs12.existsSync(PID_FILE)) {
+  if (fs13.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs12.readFileSync(PID_FILE, "utf8").trim());
+      const pid = Number(fs13.readFileSync(PID_FILE, "utf8").trim());
       if (Number.isFinite(pid) && pid > 0) {
         try {
           process.kill(pid, "SIGTERM");
@@ -1201,27 +1430,194 @@ async function stopEmulator(logger = noopLogger) {
       logger.warn(`Could not read PID file: ${err.message}`);
     }
   }
-  const killCmd = os8.platform() === "win32" ? "taskkill /IM qemu-system-x86_64.exe /F" : "pkill -f qemu-system-x86_64";
+  const [killCmd, ...killArgs] = os8.platform() === "win32" ? ["taskkill", "/IM", "qemu-system-x86_64.exe", "/F"] : ["pkill", "-f", "qemu-system-x86_64"];
   try {
-    await execPromise(killCmd, void 0, logger);
-  } catch {
+    await runProcess({ command: killCmd, args: killArgs, logger });
+  } catch (err) {
+    logger.warn(`[emulator] could not run ${killCmd}: ${err.message}`);
   }
-  fs12.rm(PID_FILE, { force: true }, (err) => {
+  fs13.rm(PID_FILE, { force: true }, (err) => {
     if (err) logger.warn(`Could not remove PID file: ${err.message}`);
   });
 }
 
+// src/hdc/devices.ts
+var STATUS_TOKENS = /* @__PURE__ */ new Set([
+  "Connected",
+  "Offline",
+  "Unauthorized",
+  "Authorizing",
+  "Disconnected",
+  "Recovery"
+]);
+var CONNECTION_TOKENS = /* @__PURE__ */ new Set(["USB", "TCP", "UART", "BT", "UNKNOWN"]);
+function parseDeviceList(stdout) {
+  const devices = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("[Empty]")) continue;
+    const cols = trimmed.split(/\s+/);
+    const serial = cols[0];
+    if (!serial) continue;
+    const rest = cols.slice(1);
+    const connection = rest.find((c) => CONNECTION_TOKENS.has(c));
+    const status = rest.find((c) => STATUS_TOKENS.has(c)) ?? "Unknown";
+    const info = { serial, status };
+    if (connection) info.connection = connection;
+    devices.push(info);
+  }
+  return devices;
+}
+async function listDevices(config, opts = {}) {
+  const res = await hdcExec({
+    config,
+    args: ["list", "targets", "-v"],
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  return parseDeviceList(res.stdout);
+}
+async function selectDevice(config, serial, opts = {}) {
+  if (serial && serial !== "auto") return serial;
+  const envSerial = process.env.ONIRO_DEVICE_SERIAL || process.env.DEVICE_SERIAL;
+  if (envSerial && envSerial !== "auto") return envSerial;
+  const usable = (await listDevices(config, opts)).filter(
+    (d) => d.status === "Connected" || d.status === "Unknown"
+  );
+  if (usable.length === 1) return usable[0].serial;
+  if (usable.length === 0) {
+    throw new OniroError("No connected device found. Connect a device/emulator or set ONIRO_DEVICE_SERIAL.");
+  }
+  throw new OniroError(
+    `Multiple devices connected (${usable.map((d) => d.serial).join(", ")}). Set ONIRO_DEVICE_SERIAL to choose one.`
+  );
+}
+
+// src/hdc/param.ts
+async function paramGet(config, key, opts = {}) {
+  const res = await shell({
+    config,
+    command: `param get ${key}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell param get ${key}`);
+  return res.stdout.trim();
+}
+async function paramSet(config, key, value, opts = {}) {
+  const res = await shell({
+    config,
+    command: `param set ${key} ${value}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell param set ${key} ${value}`);
+}
+
+// src/hdc/files.ts
+async function sendFile(opts) {
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["file", "send", opts.local, opts.remote],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc file send ${opts.local} ${opts.remote}`);
+}
+async function recvFile(opts) {
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["file", "recv", opts.remote, opts.local],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc file recv ${opts.remote} ${opts.local}`);
+}
+
+// src/hdc/display.ts
+async function getDisplaySize(config, opts = {}) {
+  const res = await shell({
+    config,
+    command: "hidumper -s 10 -a screen",
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  if (res.code !== 0) return null;
+  const m = res.stdout.match(/render resolution=(\d+)x(\d+)/);
+  if (!m) return null;
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+
+// src/hdc/wait.ts
+function delay(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new CancelledError("Wait cancelled."));
+      return;
+    }
+    const onAbort = () => {
+      cleanup();
+      reject(new CancelledError("Wait cancelled."));
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve2();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function waitForCondition(opts) {
+  const pollMs = opts.pollMs ?? 2e3;
+  const heartbeatEvery = opts.heartbeatEvery ?? 6;
+  const deadline = Date.now() + opts.timeoutMs;
+  let attempt = 0;
+  while (Date.now() < deadline) {
+    if (opts.abortSignal?.aborted) throw new CancelledError("Wait cancelled.");
+    attempt++;
+    let ok = false;
+    try {
+      ok = await opts.probe();
+    } catch {
+      ok = false;
+    }
+    if (ok) return;
+    if (opts.onHeartbeat && attempt % heartbeatEvery === 0) {
+      opts.onHeartbeat(attempt, Math.max(0, deadline - Date.now()));
+    }
+    await delay(pollMs, opts.abortSignal);
+  }
+  throw new OniroError(opts.timeoutMessage ?? `Condition not met within ${opts.timeoutMs}ms.`);
+}
+
+// src/hdc/app.ts
+import * as fs15 from "fs";
+import * as path14 from "path";
+import { spawn as spawn3 } from "child_process";
+
 // src/hdc/project.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path13 from "path";
 import JSON53 from "json5";
 function readJson5(filePath) {
-  const content = fs13.readFileSync(filePath, "utf-8");
+  const content = fs14.readFileSync(filePath, "utf-8");
   return JSON53.parse(content);
 }
 function getBundleName(projectDir) {
   const appJsonPath = path13.join(projectDir, "AppScope", "app.json5");
-  if (!fs13.existsSync(appJsonPath)) {
+  if (!fs14.existsSync(appJsonPath)) {
     throw new OniroError(`Could not find app.json5 at ${appJsonPath}`);
   }
   const appJson = readJson5(appJsonPath);
@@ -1230,59 +1626,72 @@ function getBundleName(projectDir) {
   }
   return appJson.app.bundleName;
 }
-function getMainAbility(projectDir, moduleName = "entry") {
+function getMainAbility(projectDir, moduleName = "entry", abilityName) {
   const moduleJsonPath = path13.join(projectDir, moduleName, "src", "main", "module.json5");
-  if (!fs13.existsSync(moduleJsonPath)) {
+  if (!fs14.existsSync(moduleJsonPath)) {
     throw new OniroError(`Could not find module.json5 at ${moduleJsonPath}`);
   }
   const moduleJson = readJson5(moduleJsonPath);
-  if (!moduleJson.module?.mainElement) {
-    throw new OniroError("mainElement not found in module.json5");
-  }
-  return moduleJson.module.mainElement;
+  const module = moduleJson.module ?? {};
+  if (abilityName) {
+    const match = module.abilities?.find((a) => a.name === abilityName);
+    if (match?.name) return match.name;
+    throw new OniroError(`Ability "${abilityName}" not found in module.json5 at ${moduleJsonPath}`);
+  }
+  if (module.mainElement) return module.mainElement;
+  const abilities = module.abilities ?? [];
+  const visible = abilities.find((a) => a.visible && a.name);
+  if (visible?.name) return visible.name;
+  const first = abilities.find((a) => a.name);
+  if (first?.name) return first.name;
+  throw new OniroError("mainElement not found in module.json5");
 }
 
 // src/hdc/app.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
-import { exec as exec2, spawn as spawn2 } from "child_process";
-function execPromise2(cmd, logger) {
-  return new Promise((resolve2, reject) => {
-    exec2(cmd, (error, stdout, stderr) => {
-      if (stdout?.trim()) logger.info(`[hdc] ${stdout.trim()}`);
-      if (stderr?.trim()) logger.warn(`[hdc] ${stderr.trim()}`);
-      if (error) {
-        logger.error(`[hdc] ${error.message}`);
-        reject(error);
-      } else {
-        resolve2();
-      }
-    });
-  });
-}
 async function installApp(opts) {
-  const logger = opts.logger ?? noopLogger;
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
   const relativeHapPath = opts.hapPath ?? opts.config.get("hapPath", defaultPaths.hapPath);
   const hapPath = path14.isAbsolute(relativeHapPath) ? relativeHapPath : path14.join(opts.projectDir, relativeHapPath);
-  if (!fs14.existsSync(hapPath)) {
+  if (!fs15.existsSync(hapPath)) {
     throw new OniroError(`HAP file not found at: ${hapPath}. Build and sign the app first.`);
   }
-  const hdc = getHdcPath(opts.config);
-  await execPromise2(`"${hdc}" install "${hapPath}"`, logger);
+  const result = await hdcExec({ config: opts.config, args: ["install", hapPath], timeoutMs: 3e5 });
+  if (result.stdout.trim()) logger.info(result.stdout.trim());
+  if (result.stderr.trim()) logger.warn(result.stderr.trim());
+  ensureOk(result, `hdc install ${hapPath}`);
+  let bundleName = "";
+  try {
+    bundleName = getBundleName(opts.projectDir);
+  } catch {
+  }
+  return { installed: true, bundleName, hapPath, output: `${result.stdout}${result.stderr}`.trim() };
+}
+function detectAaStartFailure(output) {
+  return /failed to start ability|Error Code:\s*\d|Error Message:/i.test(output) ? output.trim() : null;
 }
 async function launchApp(opts) {
-  const logger = opts.logger ?? noopLogger;
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
   const bundleName = getBundleName(opts.projectDir);
-  const mainAbility = getMainAbility(opts.projectDir, opts.moduleName);
-  const hdc = getHdcPath(opts.config);
-  await execPromise2(`"${hdc}" shell aa start -a ${mainAbility} -b ${bundleName}`, logger);
+  const mainAbility = getMainAbility(opts.projectDir, opts.moduleName, opts.abilityName);
+  const result = await hdcExec({
+    config: opts.config,
+    args: ["shell", "aa", "start", "-a", mainAbility, "-b", bundleName]
+  });
+  if (result.stdout.trim()) logger.info(result.stdout.trim());
+  if (result.stderr.trim()) logger.warn(result.stderr.trim());
+  ensureOk(result, `hdc shell aa start -a ${mainAbility} -b ${bundleName}`);
+  const failure = detectAaStartFailure(`${result.stdout}
+${result.stderr}`);
+  if (failure) {
+    throw new OniroError(`Failed to launch ${bundleName} (${mainAbility}): ${failure}`);
+  }
 }
 function listRunningProcesses(config, options = {}) {
   const logger = options.logger ?? noopLogger;
   const timeoutMs = options.timeoutMs ?? 1e3;
   const hdc = getHdcPath(config);
   return new Promise((resolve2, reject) => {
-    const proc = spawn2(hdc, ["track-jpid"]);
+    const proc = spawn3(hdc, ["track-jpid"]);
     const processes = [];
     let resolved = false;
     proc.stdout.on("data", (data) => {
@@ -1336,14 +1745,395 @@ async function findAppProcessId(config, projectDir, logger) {
   const result = await listRunningProcesses(config, { targetProcessName: bundleName, logger });
   return result;
 }
+async function findRunningProcess(opts) {
+  const safe = opts.bundle.replace(/'/g, `'\\''`);
+  const res = await shell({
+    config: opts.config,
+    command: `pidof '${safe}'`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  const pid = res.stdout.trim().split(/\s+/).filter(Boolean)[0];
+  if (res.code !== 0 || !pid || !/^\d+$/.test(pid)) return null;
+  return { pid, name: opts.bundle };
+}
+async function uninstallApp(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["uninstall", opts.bundle],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 12e4
+  });
+  if (res.stdout.trim()) logger.info(res.stdout.trim());
+  if (res.stderr.trim()) logger.warn(res.stderr.trim());
+  ensureOk(res, `hdc uninstall ${opts.bundle}`);
+}
+async function forceStop(opts) {
+  const res = await shell({
+    config: opts.config,
+    command: `aa force-stop ${opts.bundle}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 3e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell aa force-stop ${opts.bundle}`);
+}
+
+// src/hdc/lifecycle.ts
+async function isReachable(config, deviceSerial) {
+  try {
+    const res = await shell({ config, command: "echo oniro_ping", deviceSerial, timeoutMs: 5e3 });
+    return res.code === 0 && res.stdout.includes("oniro_ping");
+  } catch {
+    return false;
+  }
+}
+var TCP_SERIAL_RE = /^.+:\d+$/;
+async function reconnectIfTcp(config, deviceSerial, logger) {
+  if (!deviceSerial || !TCP_SERIAL_RE.test(deviceSerial)) return;
+  try {
+    await hdcExec({ config, args: ["tconn", deviceSerial], timeoutMs: 5e3, logger });
+  } catch {
+  }
+}
+async function waitForBundle(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  await waitForCondition({
+    probe: async () => {
+      await reconnectIfTcp(opts.config, opts.deviceSerial, logger);
+      return await findRunningProcess({ config: opts.config, bundle: opts.bundle, deviceSerial: opts.deviceSerial, timeoutMs: 8e3 }) !== null;
+    },
+    timeoutMs,
+    pollMs: 2e3,
+    abortSignal: opts.abortSignal,
+    onHeartbeat: (attempt, remaining) => logger.info(`waiting for ${opts.bundle} (attempt ${attempt}, ${Math.floor(remaining / 1e3)}s left)`),
+    timeoutMessage: `Bundle ${opts.bundle} did not start within ${timeoutMs}ms.`
+  });
+}
+async function waitForBoot(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  await waitForCondition({
+    probe: async () => {
+      await reconnectIfTcp(opts.config, opts.deviceSerial, logger);
+      if (!await isReachable(opts.config, opts.deviceSerial)) return false;
+      if (!opts.untilPidOf) return true;
+      return await findRunningProcess({ config: opts.config, bundle: opts.untilPidOf, deviceSerial: opts.deviceSerial, timeoutMs: 8e3 }) !== null;
+    },
+    timeoutMs,
+    pollMs: 2e3,
+    abortSignal: opts.abortSignal,
+    onHeartbeat: (attempt, remaining) => logger.info(`waiting for boot (attempt ${attempt}, ${Math.floor(remaining / 1e3)}s left)`),
+    timeoutMessage: `Device did not boot within ${timeoutMs}ms.`
+  });
+}
+async function reboot(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const mode = opts.mode ?? "system";
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  logger.info(`Rebooting device (${mode})...`);
+  try {
+    if (mode === "system") {
+      await paramSet(opts.config, "ohos.startup.powerctrl", "reboot", {
+        deviceSerial: opts.deviceSerial,
+        timeoutMs: 15e3,
+        logger: opts.logger
+      });
+    } else {
+      await shell({ config: opts.config, command: `reboot ${mode}`, deviceSerial: opts.deviceSerial, timeoutMs: 15e3 });
+    }
+  } catch (err) {
+    logger.debug(`reboot command did not return cleanly: ${err.message}`);
+  }
+  if (mode !== "system" || !opts.waitForBundle) return;
+  try {
+    await waitForCondition({
+      probe: async () => !await isReachable(opts.config, opts.deviceSerial),
+      timeoutMs: Math.min(timeoutMs, 3e4),
+      pollMs: 1500,
+      abortSignal: opts.abortSignal,
+      timeoutMessage: "device did not become unreachable"
+    });
+  } catch {
+  }
+  await waitForBundle({
+    config: opts.config,
+    bundle: opts.waitForBundle,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs,
+    abortSignal: opts.abortSignal,
+    logger: opts.logger
+  });
+}
+
+// src/hdc/screen.ts
+import * as fs16 from "fs";
+import * as os9 from "os";
+import * as path15 from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+function tmpName(ext) {
+  return path15.join(os9.tmpdir(), `oniro_screen_${randomBytes2(6).toString("hex")}.${ext}`);
+}
+async function takeScreenshot(opts) {
+  const remote = "/data/local/tmp/oniro_screenshot.jpeg";
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const cap = await shell({ config: opts.config, command: `snapshot_display -f ${remote}`, deviceSerial: opts.deviceSerial, timeoutMs });
+  ensureOk(cap, `snapshot_display -f ${remote}`);
+  const local = tmpName("jpeg");
+  try {
+    await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
+    const pixels = await fs16.promises.readFile(local);
+    const size = await getDisplaySize(opts.config, { deviceSerial: opts.deviceSerial }) ?? { width: 0, height: 0 };
+    return { pixels, width: size.width, height: size.height };
+  } finally {
+    fs16.promises.unlink(local).catch(() => {
+    });
+    void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+}
+async function captureBurst(opts) {
+  const count = Math.max(1, Math.floor(opts.count));
+  const remoteDir = `/data/local/tmp/oniro_burst_${randomBytes2(6).toString("hex")}`;
+  const sleepSec = opts.intervalMs > 0 ? (opts.intervalMs / 1e3).toFixed(3) : "0";
+  const loop = `mkdir -p ${remoteDir}; i=0; while [ $i -lt ${count} ]; do snapshot_display -f ${remoteDir}/f$i.jpeg; [ ${count} -gt 1 ] && sleep ${sleepSec}; i=$((i+1)); done`;
+  const cap = await shell({ config: opts.config, command: loop, deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 12e4 });
+  ensureOk(cap, "snapshot_display burst");
+  const frames = [];
+  try {
+    for (let i = 0; i < count; i++) {
+      const local = tmpName(`burst_${i}.jpeg`);
+      try {
+        await recvFile({ config: opts.config, remote: `${remoteDir}/f${i}.jpeg`, local, deviceSerial: opts.deviceSerial });
+        frames.push(await fs16.promises.readFile(local));
+      } finally {
+        fs16.promises.unlink(local).catch(() => {
+        });
+      }
+    }
+  } finally {
+    void shell({ config: opts.config, command: `rm -rf ${remoteDir}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+  return frames;
+}
+
+// src/hdc/input.ts
+function reqNum(value, name, type) {
+  if (value === void 0 || Number.isNaN(value)) {
+    throw new OniroError(`send input "${type}" requires a numeric ${name}.`);
+  }
+  return value;
+}
+function buildInputCommand(opts) {
+  switch (opts.type) {
+    case "click":
+    case "doubleClick":
+    case "longClick":
+      return `uitest uiInput ${opts.type} ${reqNum(opts.pxX, "pxX", opts.type)} ${reqNum(opts.pxY, "pxY", opts.type)}`;
+    case "swipe":
+    case "drag":
+    case "fling": {
+      const base = `uitest uiInput ${opts.type} ${reqNum(opts.pxX, "pxX", opts.type)} ${reqNum(opts.pxY, "pxY", opts.type)} ${reqNum(opts.pxX2, "pxX2", opts.type)} ${reqNum(opts.pxY2, "pxY2", opts.type)}`;
+      return opts.speed !== void 0 ? `${base} ${opts.speed}` : base;
+    }
+    case "keyEvent":
+      if (opts.key === void 0 || opts.key === "") throw new OniroError('send input "keyEvent" requires a key.');
+      return `uitest uiInput keyEvent ${opts.key}`;
+    case "inputText": {
+      const t = String(opts.text ?? "").replace(/'/g, `'\\''`);
+      if (opts.pxX !== void 0 && opts.pxY !== void 0) {
+        return `uitest uiInput inputText ${opts.pxX} ${opts.pxY} '${t}'`;
+      }
+      return `uitest uiInput text '${t}'`;
+    }
+  }
+}
+async function sendInput(opts) {
+  const cmd = buildInputCommand(opts);
+  const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureOk(res, `hdc shell ${cmd}`);
+}
+function buildGestureCommands(waypoints) {
+  if (waypoints.length < 2) {
+    throw new OniroError("sendGesture requires at least two waypoints.");
+  }
+  const cmds = [];
+  for (let i = 1; i < waypoints.length; i++) {
+    const a = waypoints[i - 1];
+    const b = waypoints[i];
+    const dt = b.t - a.t;
+    const dist = Math.hypot(b.x - a.x, b.y - a.y);
+    let cmd = `uitest uiInput drag ${a.x} ${a.y} ${b.x} ${b.y}`;
+    if (dt > 0 && dist > 0) cmd += ` ${Math.round(dist / (dt / 1e3))}`;
+    cmds.push(cmd);
+  }
+  return cmds;
+}
+function buildRawTouchCommand(events) {
+  if (events.length === 0) throw new OniroError("sendRawTouch requires at least one event.");
+  const ops = [];
+  let prev = null;
+  for (const ev of events) {
+    if (prev && ev.t > prev.t) ops.push(`-i ${ev.t - prev.t}`);
+    if (ev.type === "down") ops.push(`-d ${ev.x} ${ev.y}`);
+    else if (ev.type === "up") ops.push(`-u ${ev.x} ${ev.y}`);
+    else ops.push(`-m ${prev ? `${prev.x} ${prev.y} ` : ""}${ev.x} ${ev.y}`);
+    prev = ev;
+  }
+  return `uinput -T ${ops.join(" ")}`;
+}
+function waypointsToRawEvents(waypoints, holdStartMs = 0, holdEndMs = 0) {
+  if (waypoints.length < 2) throw new OniroError("sendGesture requires at least two waypoints.");
+  const first = waypoints[0];
+  const events = [{ type: "down", x: first.x, y: first.y, t: 0 }];
+  for (let i = 1; i < waypoints.length; i++) {
+    const w = waypoints[i];
+    events.push({ type: "move", x: w.x, y: w.y, t: w.t + holdStartMs });
+  }
+  const last = waypoints[waypoints.length - 1];
+  events.push({ type: "up", x: last.x, y: last.y, t: last.t + holdStartMs + holdEndMs });
+  return events;
+}
+async function sendGesture(opts) {
+  const wantsHold = (opts.holdStartMs ?? 0) > 0 || (opts.holdEndMs ?? 0) > 0;
+  if (wantsHold) {
+    await sendRawTouch({
+      config: opts.config,
+      events: waypointsToRawEvents(opts.waypoints, opts.holdStartMs, opts.holdEndMs),
+      deviceSerial: opts.deviceSerial,
+      logger: opts.logger
+    });
+    return;
+  }
+  for (const cmd of buildGestureCommands(opts.waypoints)) {
+    const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+    ensureOk(res, `hdc shell ${cmd}`);
+  }
+}
+async function sendRawTouch(opts) {
+  const cmd = buildRawTouchCommand(opts.events);
+  const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureOk(res, `hdc shell ${cmd}`);
+}
+
+// src/hdc/dump.ts
+import * as fs17 from "fs";
+import * as os10 from "os";
+import * as path16 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
+function parseBounds(s) {
+  const m = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/.exec(s ?? "");
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+}
+var STRUCTURAL_TYPES = /* @__PURE__ */ new Set([
+  "Stack",
+  "Column",
+  "Row",
+  "Flex",
+  "__Common__",
+  "Grid",
+  "GridItem",
+  "List",
+  "ListItem",
+  "Scroll",
+  "Swiper",
+  "SwiperContent",
+  "Navigator",
+  "Tabs",
+  "TabContent",
+  "RelativeContainer",
+  "WaterFlow",
+  "FlowItem"
+]);
+var FLAG_MAP = [
+  ["clickable", "click"],
+  ["checkable", "check"],
+  ["checked", "checked"],
+  ["selected", "sel"],
+  ["focused", "focus"],
+  ["scrollable", "scroll"],
+  ["longClickable", "longClick"]
+];
+function pruneLayout(node, display) {
+  const a = node.attributes ?? {};
+  const px = parseBounds(a.bounds);
+  const out = {};
+  if (px && display) {
+    const w = display.width || 1;
+    const h = display.height || 1;
+    out.b = [
+      +(px[0] / w).toFixed(3),
+      +(px[1] / h).toFixed(3),
+      +(px[2] / w).toFixed(3),
+      +(px[3] / h).toFixed(3)
+    ];
+    out.c = [+((px[0] + px[2]) / 2 / w).toFixed(3), +((px[1] + px[3]) / 2 / h).toFixed(3)];
+  }
+  if (a.type && !STRUCTURAL_TYPES.has(a.type)) out.type = a.type;
+  if (a.text) out.text = a.text;
+  if (a.description) out.desc = a.description;
+  if (a.id) out.id = a.id;
+  if (a.key && a.key !== a.id) out.key = a.key;
+  if (a.bundleName) out.bundle = a.bundleName;
+  for (const [attr, short] of FLAG_MAP) {
+    if (a[attr] === "true") out[short] = true;
+  }
+  const children = [];
+  for (const c of node.children ?? []) {
+    const pc = pruneLayout(c, display);
+    if (pc) {
+      if (Array.isArray(pc)) children.push(...pc);
+      else children.push(pc);
+    }
+  }
+  const hasSignal = Boolean(
+    out.text || out.desc || out.id || out.key || out.click || out.scroll || out.check || out.longClick || out.bundle || out.type && out.type !== "root"
+  );
+  if (!hasSignal && children.length === 0) return null;
+  if (!hasSignal) return children.length === 1 ? children[0] : children;
+  if (children.length) out.children = children;
+  return out;
+}
+async function dumpLayout(opts) {
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const bundleArg = opts.bundleName ? ` -b '${opts.bundleName.replace(/'/g, `'\\''`)}'` : "";
+  const dump = await shell({ config: opts.config, command: `uitest dumpLayout${bundleArg}`, deviceSerial: opts.deviceSerial, timeoutMs });
+  ensureOk(dump, "uitest dumpLayout");
+  const m = dump.stdout.match(/saved to:\s*(\S+)/i);
+  if (!m) throw new OniroError(`Could not parse dumpLayout output:
+${dump.stdout}`);
+  const remote = m[1];
+  const local = path16.join(os10.tmpdir(), `oniro_layout_${randomBytes3(6).toString("hex")}.json`);
+  try {
+    await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
+    const parsed = JSON.parse(await fs17.promises.readFile(local, "utf8"));
+    const display = await getDisplaySize(opts.config, { deviceSerial: opts.deviceSerial });
+    if (opts.prune === false) {
+      return { display, tree: parsed };
+    }
+    const prunedRaw = pruneLayout(parsed, display);
+    const tree = Array.isArray(prunedRaw) ? { children: prunedRaw } : prunedRaw ?? { children: [] };
+    return { display, tree };
+  } finally {
+    fs17.promises.unlink(local).catch(() => {
+    });
+    void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+}
 
 // src/hdc/hilog.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function setHilogLevel(opts) {
   const logger = opts.logger ?? noopLogger;
   const hdc = getHdcPath(opts.config);
   return new Promise((resolve2, reject) => {
-    const child = spawn3(hdc, ["shell", "hilog", "-b", opts.level]);
+    const child = spawn4(hdc, ["shell", "hilog", "-b", opts.level]);
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -1365,11 +2155,16 @@ function setHilogLevel(opts) {
 }
 function streamHilog(opts) {
   const hdc = getHdcPath(opts.config);
-  const args = ["shell", "hilog"];
+  const args = [];
+  if (opts.deviceSerial) args.push("-t", opts.deviceSerial);
+  args.push("shell", "hilog");
   if (opts.processId && opts.processId.trim() !== "") {
     args.push("-P", opts.processId.trim());
   }
-  return spawn3(hdc, args);
+  if (opts.domain !== void 0 && `${opts.domain}` !== "") {
+    args.push("-D", `${opts.domain}`);
+  }
+  return spawn4(hdc, args);
 }
 var HILOG_LINE_RE = /^(\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\s+(\d+)\s+(\d+)\s+([DIWEF])\s+(\S+):\s+(.*)$/;
 function parseHilogLine(line) {
@@ -1384,30 +2179,194 @@ function parseHilogLine(line) {
     message: match[6]
   };
 }
+function entryText(e) {
+  return `${e.tag}: ${e.message}`;
+}
+function dedupEntries(entries) {
+  const out = [];
+  let lastKey = "";
+  for (const e of entries) {
+    const key = `${e.level}|${e.tag}|${e.message}`;
+    if (key === lastKey) continue;
+    out.push(e);
+    lastKey = key;
+  }
+  return out;
+}
+async function resolveProcessId(config, bundle, deviceSerial) {
+  if (!bundle) return void 0;
+  const proc = await findRunningProcess({ config, bundle, deviceSerial });
+  return proc?.pid;
+}
+function waitForLog(opts) {
+  return new Promise((resolve2, reject) => {
+    const deadline = Date.now() + opts.timeoutMs;
+    let settled = false;
+    let child = null;
+    let reconnectTimer;
+    let buf = "";
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      opts.abortSignal?.removeEventListener("abort", onAbort);
+      if (child) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        child = null;
+      }
+    };
+    const finish = (entry) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve2(entry);
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onAbort = () => fail(new CancelledError("waitForLog cancelled."));
+    const timer = setTimeout(
+      () => fail(new OniroError(`No log line matched ${String(opts.pattern)} within ${opts.timeoutMs}ms.`)),
+      opts.timeoutMs
+    );
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    const spawnStream = async () => {
+      if (settled) return;
+      const processId = await resolveProcessId(opts.config, opts.bundle, opts.deviceSerial);
+      if (settled) return;
+      const stream = streamHilog({ config: opts.config, processId, domain: opts.domain, deviceSerial: opts.deviceSerial });
+      child = stream;
+      stream.stdout.on("data", (d) => {
+        buf += d.toString();
+        let idx;
+        while ((idx = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          const entry = parseHilogLine(line);
+          if (entry && opts.pattern.test(entryText(entry))) {
+            finish(entry);
+            return;
+          }
+        }
+      });
+      const onEnd = () => {
+        if (settled || child !== stream) return;
+        child = null;
+        if (Date.now() < deadline) {
+          reconnectTimer = setTimeout(() => void spawnStream(), 1e3);
+        }
+      };
+      stream.once("close", onEnd);
+      stream.once("error", onEnd);
+    };
+    void spawnStream();
+  });
+}
+function watchLog(opts) {
+  return new Promise((resolve2, reject) => {
+    const matches = [];
+    let settled = false;
+    let child = null;
+    let buf = "";
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts.abortSignal?.removeEventListener("abort", onAbort);
+      if (child) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        child = null;
+      }
+    };
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve2(opts.dedup === false ? matches : dedupEntries(matches));
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new CancelledError("watchLog cancelled."));
+    };
+    const timer = setTimeout(done, opts.durationMs);
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    void (async () => {
+      const processId = await resolveProcessId(opts.config, opts.bundle, opts.deviceSerial);
+      if (settled) return;
+      const stream = streamHilog({ config: opts.config, processId, domain: opts.domain, deviceSerial: opts.deviceSerial });
+      child = stream;
+      stream.stdout.on("data", (d) => {
+        buf += d.toString();
+        let idx;
+        while ((idx = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          const entry = parseHilogLine(line);
+          if (entry && opts.pattern.test(entryText(entry))) matches.push(entry);
+        }
+      });
+    })();
+  });
+}
+async function dumpLog(opts) {
+  let pipe = "hilog -x";
+  if (opts.domain !== void 0 && `${opts.domain}` !== "") pipe += ` -D ${opts.domain}`;
+  if (opts.bundle) {
+    const proc = await findRunningProcess({ config: opts.config, bundle: opts.bundle, deviceSerial: opts.deviceSerial });
+    if (!proc) return [];
+    pipe += ` | grep -E '\\b${proc.pid}\\b'`;
+  }
+  if (opts.grep) {
+    const safeGrep = opts.grep.replace(/'/g, `'\\''`);
+    pipe += ` | grep -E '${safeGrep}'`;
+  }
+  if (opts.lines && opts.lines > 0) pipe += ` | tail -n ${Math.floor(opts.lines)}`;
+  const res = await shell({
+    config: opts.config,
+    command: pipe,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 3e4,
+    logger: opts.logger
+  });
+  return res.stdout.split("\n").map((line) => parseHilogLine(line)).filter((e) => e !== null);
+}
 
 // src/build/runHvigorw.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
-import { spawn as spawn4 } from "child_process";
+import * as fs18 from "fs";
+import * as path17 from "path";
+import { spawn as spawn5 } from "child_process";
+function buildHvigorwArgs(opts) {
+  const args = [opts.task ?? "assembleHap", "--mode", "module"];
+  args.push("-p", `product=${opts.product ?? "default"}`);
+  if (opts.module) args.push("-p", `module=${opts.module}`);
+  if (opts.buildMode) args.push("-p", `buildMode=${opts.buildMode}`);
+  args.push("--stacktrace", "--no-daemon");
+  if (opts.parallel === false) args.push("--no-parallel");
+  if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+  return args;
+}
 function runHvigorw(opts) {
   const { config, projectDir } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (!fs15.existsSync(path15.join(projectDir, "build-profile.json5"))) {
+  if (!fs18.existsSync(path17.join(projectDir, "build-profile.json5"))) {
     throw new OniroError(`Not an OpenHarmony project: ${projectDir} (build-profile.json5 not found).`);
   }
-  if (!fs15.existsSync(getCmdToolsPath(config))) {
+  if (!fs18.existsSync(getCmdToolsPath(config))) {
     throw new CmdToolsNotInstalledError(getCmdToolsPath(config));
   }
   const hvigorw = getHvigorwPath(config, projectDir);
-  const args = [opts.task ?? "assembleHap", "--mode", "module"];
-  args.push("-p", `product=${opts.product ?? "default"}`);
-  if (opts.module) args.push("-p", `module=${opts.module}`);
-  if (opts.buildMode) args.push("-p", `buildMode=${opts.buildMode}`);
-  args.push("--stacktrace", "--no-parallel", "--no-daemon");
-  if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+  const args = buildHvigorwArgs(opts);
   if (process.platform !== "win32") {
     try {
-      fs15.chmodSync(hvigorw, 493);
+      fs18.chmodSync(hvigorw, 493);
     } catch {
     }
   }
@@ -1416,8 +2375,25 @@ function runHvigorw(opts) {
     OHOS_BASE_SDK_HOME: getOhosBaseSdkHome(config)
   };
   return new Promise((resolve2, reject) => {
+    if (opts.abortSignal?.aborted) {
+      reject(new CancelledError("hvigorw build cancelled."));
+      return;
+    }
     logger.info(`[build] ${hvigorw} ${args.join(" ")}`);
-    const child = spawn4(hvigorw, args, { cwd: projectDir, env, shell: false });
+    const child = spawn5(hvigorw, args, { cwd: projectDir, env, shell: false });
+    let settled = false;
+    const cleanup = () => opts.abortSignal?.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new CancelledError("hvigorw build cancelled."));
+    };
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
     child.stdout.on("data", (chunk) => {
       const text = chunk.toString();
       opts.onOutput?.(text, "stdout");
@@ -1428,8 +2404,16 @@ function runHvigorw(opts) {
       opts.onOutput?.(text, "stderr");
       logger.warn(text.trimEnd());
     });
-    child.on("error", (err) => reject(new OniroError(`Failed to start hvigorw: ${err.message}`, err)));
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new OniroError(`Failed to start hvigorw: ${err.message}`, err));
+    });
     child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
       const exitCode = code ?? 1;
       if (exitCode === 0) resolve2({ exitCode });
       else reject(new OniroError(`hvigorw exited with code ${exitCode}`));
@@ -1437,6 +2421,137 @@ function runHvigorw(opts) {
   });
 }
 
+// src/build/discoverHaps.ts
+import * as fs19 from "fs";
+import * as path18 from "path";
+function moduleOf(projectDir, hapPath) {
+  const rel = path18.relative(projectDir, hapPath);
+  const first = rel.split(path18.sep)[0];
+  return first && first !== ".." ? first : "(root)";
+}
+async function discoverHaps(opts) {
+  const { projectDir } = opts;
+  const maxDepth = opts.maxDepth ?? 8;
+  const result = {};
+  const walk = async (dir, depth) => {
+    if (depth > maxDepth) return;
+    const entries = await fs19.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      const full = path18.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (e.name === "node_modules" || e.name === "oh_modules" || e.name === ".git") continue;
+        await walk(full, depth + 1);
+      } else if (e.isFile() && e.name.endsWith(".hap")) {
+        const moduleName = moduleOf(projectDir, full);
+        const bucket = result[moduleName] ??= { signed: [], unsigned: [] };
+        if (e.name.includes("unsigned")) bucket.unsigned.push(full);
+        else if (e.name.includes("signed")) bucket.signed.push(full);
+      }
+    }
+  };
+  await walk(projectDir, 0);
+  return result;
+}
+
+// src/build/ohpm.ts
+import * as fs20 from "fs";
+import * as path19 from "path";
+function runOhpm(opts) {
+  return runProcess({
+    command: getOhpmPath(opts.config),
+    args: [...opts.args],
+    cwd: opts.projectDir,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+}
+async function ensureOhModules(opts) {
+  if (fs20.existsSync(path19.join(opts.projectDir, "oh_modules"))) {
+    return { installed: false };
+  }
+  const res = await runOhpm({
+    config: opts.config,
+    projectDir: opts.projectDir,
+    args: ["install", "--all"],
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, "ohpm install --all");
+  return { installed: true };
+}
+
+// src/build/codelinter.ts
+var FINDING_RE = /^(.*?):(\d+):(?:\d+:)?\s*(error|warning|warn|info)\b[:\s-]*(.*)$/i;
+var TRAILING_CODE_RE = /[([]([\w@/.\-]+)[)\]]\s*$/;
+function parseCodelinterFindings(output) {
+  const findings = [];
+  for (const raw of output.split("\n")) {
+    const m = FINDING_RE.exec(raw.trim());
+    if (!m) continue;
+    let message = m[4].trim();
+    let code = "";
+    const codeMatch = TRAILING_CODE_RE.exec(message);
+    if (codeMatch) {
+      code = codeMatch[1];
+      message = message.slice(0, codeMatch.index).trim();
+    }
+    findings.push({ file: m[1].trim(), line: Number(m[2]), severity: m[3].toLowerCase(), code, message });
+  }
+  return findings;
+}
+async function runCodelinter(opts) {
+  const res = await runProcess({
+    command: getCmdToolsBin(opts.config, "codelinter"),
+    args: opts.files?.length ? [...opts.files] : [],
+    cwd: opts.projectDir,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    logger: opts.logger
+  });
+  const raw = `${res.stdout}${res.stderr}`;
+  return { code: res.code, findings: parseCodelinterFindings(raw), raw };
+}
+
+// src/build/buildHap.ts
+async function buildHap(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "build");
+  const warnings = [];
+  const start = Date.now();
+  if (opts.autoInstallDeps !== false) {
+    const r = await ensureOhModules({
+      config: opts.config,
+      projectDir: opts.projectDir,
+      abortSignal: opts.abortSignal,
+      onOutput: opts.onOutput,
+      logger: opts.logger
+    });
+    if (r.installed) logger.info("ran ohpm install --all (oh_modules was missing)");
+  }
+  const { exitCode } = await runHvigorw({
+    config: opts.config,
+    projectDir: opts.projectDir,
+    product: opts.product,
+    module: opts.module,
+    buildMode: opts.mode,
+    task: opts.task,
+    parallel: opts.parallel,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  const discoveredHaps = await discoverHaps({ projectDir: opts.projectDir });
+  const anySigned = Object.values(discoveredHaps).some((m) => m.signed.length > 0);
+  if (!anySigned) {
+    warnings.push(
+      "No signed HAPs found \u2014 configure signingConfigs in build-profile.json5 (unsigned HAPs are rejected by most devices)."
+    );
+  }
+  return { exitCode, durationMs: Date.now() - start, discoveredHaps, warnings };
+}
+
 // src/project/validators.ts
 function isValidProjectName(name) {
   if (!name) return false;
@@ -1448,21 +2563,21 @@ function isValidBundleName(bundleName) {
 }
 
 // src/project/templates.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 function toHumanTemplateName(folderName) {
   return folderName.replace(/([a-z])([A-Z])/g, "$1 $2");
 }
 function listTemplates(templateRoot) {
-  if (!fs16.existsSync(templateRoot)) return [];
-  const entries = fs16.readdirSync(templateRoot, { withFileTypes: true });
+  if (!fs21.existsSync(templateRoot)) return [];
+  const entries = fs21.readdirSync(templateRoot, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => {
-    const dir = path16.join(templateRoot, e.name);
-    const metaPath = path16.join(dir, "template.json");
+    const dir = path20.join(templateRoot, e.name);
+    const metaPath = path20.join(dir, "template.json");
     let meta = {};
-    if (fs16.existsSync(metaPath)) {
+    if (fs21.existsSync(metaPath)) {
       try {
-        meta = JSON.parse(fs16.readFileSync(metaPath, "utf8"));
+        meta = JSON.parse(fs21.readFileSync(metaPath, "utf8"));
       } catch {
       }
     }
@@ -1477,57 +2592,57 @@ function listTemplates(templateRoot) {
 function validateTemplateLayout(templateDir, defaultModuleName) {
   const required = [
     "build-profile.json5",
-    path16.join("AppScope", "app.json5"),
-    path16.join(defaultModuleName, "src", "main", "module.json5"),
-    path16.join(defaultModuleName, "oh-package.json5"),
+    path20.join("AppScope", "app.json5"),
+    path20.join(defaultModuleName, "src", "main", "module.json5"),
+    path20.join(defaultModuleName, "oh-package.json5"),
     "hvigorfile.ts"
   ];
-  return required.filter((rel) => !fs16.existsSync(path16.join(templateDir, rel)));
+  return required.filter((rel) => !fs21.existsSync(path20.join(templateDir, rel)));
 }
 
 // src/project/createScaffold.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 
 // src/project/jsonHelpers.ts
-import * as fs17 from "fs";
+import * as fs22 from "fs";
 import JSON54 from "json5";
 function readJson5File(filePath) {
-  return JSON54.parse(fs17.readFileSync(filePath, "utf8"));
+  return JSON54.parse(fs22.readFileSync(filePath, "utf8"));
 }
 function writeJson5File(filePath, value) {
-  fs17.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  fs22.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 function readJsonFile(filePath) {
-  return JSON.parse(fs17.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs22.readFileSync(filePath, "utf8"));
 }
 function writeJsonFile(filePath, value) {
-  fs17.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  fs22.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 
 // src/project/createScaffold.ts
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["oh_modules", "node_modules", "build", ".hvigor"]);
 async function pathExists(p) {
   try {
-    await fs18.promises.access(p);
+    await fs23.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function copyDirRecursive(srcDir, destDir) {
-  await fs18.promises.mkdir(destDir, { recursive: true });
-  const entries = await fs18.promises.readdir(srcDir, { withFileTypes: true });
+  await fs23.promises.mkdir(destDir, { recursive: true });
+  const entries = await fs23.promises.readdir(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const src = path17.join(srcDir, entry.name);
-    const dest = path17.join(destDir, entry.name);
+    const src = path21.join(srcDir, entry.name);
+    const dest = path21.join(destDir, entry.name);
     if (entry.isDirectory()) {
       await copyDirRecursive(src, dest);
     } else if (entry.isSymbolicLink()) {
       continue;
     } else if (entry.isFile()) {
       if (entry.name === "template.json") continue;
-      await fs18.promises.copyFile(src, dest);
+      await fs23.promises.copyFile(src, dest);
     }
   }
 }
@@ -1535,9 +2650,9 @@ async function normalizeJson5ToJson(projectDir, logger) {
   const stack = [projectDir];
   while (stack.length > 0) {
     const currentDir = stack.pop();
-    const entries = await fs18.promises.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs23.promises.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path17.join(currentDir, entry.name);
+      const fullPath = path21.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         stack.push(fullPath);
@@ -1559,23 +2674,23 @@ function toJavaPropertiesPath(p) {
 function createOrUpdateLocalProperties(projectDir, sdkDir) {
   const content = `sdk.dir=${toJavaPropertiesPath(sdkDir)}
 `;
-  fs18.writeFileSync(path17.join(projectDir, "local.properties"), content, "utf8");
+  fs23.writeFileSync(path21.join(projectDir, "local.properties"), content, "utf8");
 }
 function renameIfExists(fromPath, toPath) {
-  if (fs18.existsSync(fromPath) && fromPath !== toPath) {
-    fs18.renameSync(fromPath, toPath);
+  if (fs23.existsSync(fromPath) && fromPath !== toPath) {
+    fs23.renameSync(fromPath, toPath);
   }
 }
 function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
-  const appJsonPath = path17.join(projectDir, "AppScope", "app.json5");
-  if (fs18.existsSync(appJsonPath)) {
+  const appJsonPath = path21.join(projectDir, "AppScope", "app.json5");
+  if (fs23.existsSync(appJsonPath)) {
     const appJson = readJson5File(appJsonPath);
     appJson.app = appJson.app ?? {};
     appJson.app.bundleName = args.bundleName;
     writeJson5File(appJsonPath, appJson);
   }
-  const stringsPath = path17.join(projectDir, "AppScope", "resources", "base", "element", "string.json");
-  if (fs18.existsSync(stringsPath)) {
+  const stringsPath = path21.join(projectDir, "AppScope", "resources", "base", "element", "string.json");
+  if (fs23.existsSync(stringsPath)) {
     const strings = readJsonFile(stringsPath);
     if (Array.isArray(strings.string)) {
       const appName = strings.string.find((s) => s.name === "app_name");
@@ -1583,8 +2698,8 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJsonFile(stringsPath, strings);
   }
-  const buildProfilePath = path17.join(projectDir, "build-profile.json5");
-  if (fs18.existsSync(buildProfilePath)) {
+  const buildProfilePath = path21.join(projectDir, "build-profile.json5");
+  if (fs23.existsSync(buildProfilePath)) {
     const buildProfile = readJson5File(buildProfilePath);
     buildProfile.app = buildProfile.app ?? {};
     if (Array.isArray(buildProfile.app.products) && buildProfile.app.products.length > 0) {
@@ -1597,23 +2712,23 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJson5File(buildProfilePath, buildProfile);
   }
-  const moduleJsonPath = path17.join(projectDir, args.moduleName, "src", "main", "module.json5");
-  if (fs18.existsSync(moduleJsonPath)) {
+  const moduleJsonPath = path21.join(projectDir, args.moduleName, "src", "main", "module.json5");
+  if (fs23.existsSync(moduleJsonPath)) {
     const moduleJson = readJson5File(moduleJsonPath);
     moduleJson.module = moduleJson.module ?? {};
     moduleJson.module.name = args.moduleName;
     writeJson5File(moduleJsonPath, moduleJson);
   }
-  const moduleOhPackagePath = path17.join(projectDir, args.moduleName, "oh-package.json5");
-  if (fs18.existsSync(moduleOhPackagePath)) {
+  const moduleOhPackagePath = path21.join(projectDir, args.moduleName, "oh-package.json5");
+  if (fs23.existsSync(moduleOhPackagePath)) {
     const pkg = readJson5File(moduleOhPackagePath);
     pkg.name = args.moduleName;
     writeJson5File(moduleOhPackagePath, pkg);
   }
-  const vscodeDir = path17.join(projectDir, ".vscode");
-  fs18.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path21.join(projectDir, ".vscode");
+  fs23.mkdirSync(vscodeDir, { recursive: true });
   const hapPath = `${args.moduleName}/build/default/outputs/default/${args.moduleName}-default-signed.hap`;
-  writeJsonFile(path17.join(vscodeDir, "settings.json"), {
+  writeJsonFile(path21.join(vscodeDir, "settings.json"), {
     "oniro.hapPath": hapPath,
     "files.associations": { "*.json5": "jsonc" }
   });
@@ -1630,7 +2745,7 @@ async function createScaffold(opts) {
   if (!opts.location || !await pathExists(opts.location)) {
     throw new OniroError(`Location does not exist: ${opts.location}`);
   }
-  const templateDir = path17.join(opts.templateRoot, opts.templateId);
+  const templateDir = path21.join(opts.templateRoot, opts.templateId);
   if (!await pathExists(templateDir)) {
     throw new OniroError(`Template not found: ${templateDir}`);
   }
@@ -1643,17 +2758,17 @@ async function createScaffold(opts) {
     throw new OniroError(`Template '${opts.templateId}' is missing required files:
 - ${missing.join("\n- ")}`);
   }
-  const projectDir = path17.join(opts.location, opts.projectName);
+  const projectDir = path21.join(opts.location, opts.projectName);
   if (await pathExists(projectDir)) {
     if (!opts.overwrite) {
       throw new OniroError(`Destination already exists: ${projectDir}. Pass overwrite: true to replace it.`);
     }
-    await fs18.promises.rm(projectDir, { recursive: true, force: true });
+    await fs23.promises.rm(projectDir, { recursive: true, force: true });
   }
   logger.info(`[create] Scaffolding ${opts.templateId} at ${projectDir}`);
   await copyDirRecursive(templateDir, projectDir);
   if (moduleName !== defaultModuleName) {
-    renameIfExists(path17.join(projectDir, defaultModuleName), path17.join(projectDir, moduleName));
+    renameIfExists(path21.join(projectDir, defaultModuleName), path21.join(projectDir, moduleName));
   }
   updateTemplateConfigs(
     projectDir,
@@ -1669,8 +2784,225 @@ async function createScaffold(opts) {
   return { projectDir };
 }
 
+// src/project/listModules.ts
+import * as fs24 from "fs";
+import * as path22 from "path";
+function listModules(opts) {
+  const buildProfile = path22.join(opts.projectDir, "build-profile.json5");
+  if (!fs24.existsSync(buildProfile)) {
+    throw new OniroError(`build-profile.json5 not found at ${buildProfile}`);
+  }
+  const parsed = readJson5File(buildProfile);
+  return (parsed.modules ?? []).filter((m) => Boolean(m.name)).map((m) => ({
+    name: m.name,
+    srcPath: m.srcPath ?? `./${m.name}`,
+    targets: (m.targets ?? []).map((t) => t.name).filter((n) => Boolean(n))
+  }));
+}
+
+// src/project/abilities.ts
+import * as fs25 from "fs";
+import * as path23 from "path";
+function listAbilities(opts) {
+  const moduleName = opts.moduleName ?? "entry";
+  const moduleJsonPath = path23.join(opts.projectDir, moduleName, "src", "main", "module.json5");
+  if (!fs25.existsSync(moduleJsonPath)) {
+    throw new OniroError(`Could not find module.json5 at ${moduleJsonPath}`);
+  }
+  const parsed = readJson5File(moduleJsonPath);
+  return (parsed.module?.abilities ?? []).filter((a) => Boolean(a.name)).map((a) => ({ name: a.name, type: a.type, visible: a.visible, srcEntry: a.srcEntry }));
+}
+
+// src/project/prepareSigning.ts
+import * as fs26 from "fs";
+import * as path24 from "path";
+function hasSigningArtifacts(dir) {
+  if (!fs26.existsSync(path24.join(dir, "signatures"))) return false;
+  const buildProfile = path24.join(dir, "build-profile.json5");
+  if (!fs26.existsSync(buildProfile)) return false;
+  try {
+    const parsed = readJson5File(buildProfile);
+    return Array.isArray(parsed.app?.signingConfigs) && parsed.app.signingConfigs.length > 0;
+  } catch {
+    return false;
+  }
+}
+function prepareSigning(opts) {
+  if (hasSigningArtifacts(opts.projectDir)) {
+    return { source: "present" };
+  }
+  generateSigningConfigs({
+    projectDir: opts.projectDir,
+    sdkHome: getOhosBaseSdkHome(opts.config),
+    apl: opts.apl,
+    appFeature: opts.appFeature,
+    acls: opts.acls,
+    passwords: opts.passwords,
+    logger: opts.logger
+  });
+  return { source: "fresh" };
+}
+
+// src/device/hidumper.ts
+async function dumpScreen(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s 10 -a screen", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 1e4, logger: opts.logger });
+  if (res.code !== 0) return null;
+  const m = res.stdout.match(/render resolution=(\d+)x(\d+)/);
+  if (!m) return null;
+  return { width: Number(m[1]), height: Number(m[2]), raw: res.stdout };
+}
+async function dumpWindow(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s WindowManagerService -a -a", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 15e3, logger: opts.logger });
+  return res.stdout;
+}
+async function dumpRenderService(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s RenderService -a allInfo", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 15e3, logger: opts.logger });
+  return res.stdout;
+}
+
+// src/device/info.ts
+var PROPS = [
+  ["model", "const.product.model"],
+  ["manufacturer", "const.product.manufacturer"],
+  ["brand", "const.product.brand"],
+  ["osFullName", "const.ohos.fullname"],
+  ["osReleaseType", "const.ohos.releasetype"],
+  ["sdkApiVersion", "const.ohos.apiversion"],
+  ["buildVersion", "const.product.software.version"]
+];
+async function getDeviceInfo(opts) {
+  const info = { serial: opts.deviceSerial ?? "(default)", display: null };
+  for (const [field, prop] of PROPS) {
+    try {
+      const value = await paramGet(opts.config, prop, { deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 1e4, logger: opts.logger });
+      if (value) info[field] = value;
+    } catch {
+    }
+  }
+  const screen = await dumpScreen({ config: opts.config, deviceSerial: opts.deviceSerial, logger: opts.logger });
+  if (screen) info.display = { width: screen.width, height: screen.height };
+  return info;
+}
+
+// src/install/diffHapAssets.ts
+import StreamZip2 from "node-stream-zip";
+function diffEntryNames(installed, next) {
+  const installedSet = new Set(installed);
+  const nextSet = new Set(next);
+  return {
+    addedAssetPaths: [...nextSet].filter((n) => !installedSet.has(n)).sort(),
+    removedAssetPaths: [...installedSet].filter((n) => !nextSet.has(n)).sort()
+  };
+}
+async function listFileEntries(hapPath) {
+  const zip = new StreamZip2.async({ file: hapPath });
+  try {
+    const entries = await zip.entries();
+    return Object.values(entries).filter((e) => !e.isDirectory).map((e) => e.name);
+  } finally {
+    await zip.close();
+  }
+}
+async function diffHapAssets(opts) {
+  const [installed, next] = await Promise.all([listFileEntries(opts.installedHap), listFileEntries(opts.newHap)]);
+  return diffEntryNames(installed, next);
+}
+
+// src/install/apply.ts
+import * as fs27 from "fs";
+import * as path25 from "path";
+function decideInstallMethod(s) {
+  if (!s.signInfoInconsistent) return "replace";
+  if (s.isSystemBundle && !s.allowUninstall) return "refuse";
+  return "uninstall-install";
+}
+function decideReboot(s) {
+  if (s.assetsChanged) return { reboot: true, reason: "asset-cache" };
+  if (s.isSystemBundle && s.preInstallPid !== null && s.postInstallPid === s.preInstallPid) {
+    return { reboot: true, reason: "pid-unchanged" };
+  }
+  return { reboot: false, reason: "none" };
+}
+var SIGN_INFO_INCONSISTENT = /9568332|sign.*info.*inconsistent/i;
+async function pidOf(config, bundle, deviceSerial) {
+  const proc = await findRunningProcess({ config, bundle, deviceSerial });
+  return proc ? Number(proc.pid) : null;
+}
+async function resolveHapPath(opts) {
+  let hapPath = opts.hapPath;
+  if (hapPath) {
+    if (!path25.isAbsolute(hapPath) && opts.projectDir) hapPath = path25.join(opts.projectDir, hapPath);
+  } else {
+    if (!opts.projectDir) throw new OniroError("applyChanges requires hapPath or projectDir.");
+    const haps = await discoverHaps({ projectDir: opts.projectDir });
+    if (opts.module) {
+      const signed = haps[opts.module]?.signed ?? [];
+      if (signed.length === 0) throw new OniroError(`No signed HAP for module ${opts.module}. Build first.`);
+      hapPath = signed[0];
+    } else {
+      const withSigned = Object.entries(haps).filter(([, m]) => m.signed.length > 0);
+      if (withSigned.length === 0) throw new OniroError("No signed HAP found. Build first.");
+      if (withSigned.length > 1) {
+        throw new OniroError(
+          `Multiple modules have signed HAPs (${withSigned.map(([k]) => k).join(", ")}). Pass module to choose.`
+        );
+      }
+      hapPath = withSigned[0][1].signed[0];
+    }
+  }
+  if (!fs27.existsSync(hapPath)) throw new OniroError(`HAP not found at ${hapPath}.`);
+  return hapPath;
+}
+async function applyChanges(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "apply");
+  const { config, bundle, deviceSerial } = opts;
+  const isSystemBundle = opts.isSystemBundle ?? false;
+  const allowUninstall = opts.allowUninstall ?? false;
+  const hapPath = await resolveHapPath(opts);
+  let assetsChanged = false;
+  if (opts.installedHapPath && fs27.existsSync(opts.installedHapPath)) {
+    try {
+      const diff = await diffHapAssets({ installedHap: opts.installedHapPath, newHap: hapPath });
+      assetsChanged = diff.addedAssetPaths.length > 0 || diff.removedAssetPaths.length > 0;
+    } catch (err) {
+      logger.debug(`asset diff skipped: ${err.message}`);
+    }
+  }
+  const preInstallPid = await pidOf(config, bundle, deviceSerial);
+  const replaceRes = await hdcExec({ config, args: ["install", "-r", hapPath], deviceSerial, timeoutMs: 3e5 });
+  const signInfoInconsistent = SIGN_INFO_INCONSISTENT.test(`${replaceRes.stdout}${replaceRes.stderr}`);
+  const decision = decideInstallMethod({ signInfoInconsistent, isSystemBundle, allowUninstall });
+  let installMethod;
+  if (decision === "refuse") {
+    throw new OniroError(
+      `Refusing to reinstall system bundle ${bundle}: signing certs are inconsistent (9568332). Align the signing certs first \u2014 uninstalling a system bundle can brick the device. Pass allowUninstall to override.`
+    );
+  }
+  if (decision === "uninstall-install") {
+    logger.warn(`sign-info inconsistent for ${bundle}; uninstalling then installing fresh.`);
+    await uninstallApp({ config, bundle, deviceSerial });
+    ensureOk(await hdcExec({ config, args: ["install", hapPath], deviceSerial, timeoutMs: 3e5 }), `hdc install ${hapPath}`);
+    installMethod = "uninstall-install";
+  } else {
+    ensureOk(replaceRes, `hdc install -r ${hapPath}`);
+    installMethod = "replace";
+  }
+  let postInstallPid = await pidOf(config, bundle, deviceSerial);
+  const rebootDecision = decideReboot({ assetsChanged, isSystemBundle, preInstallPid, postInstallPid });
+  let method = installMethod;
+  let cacheCleared = false;
+  if (rebootDecision.reboot) {
+    logger.info(`rebooting (${rebootDecision.reason}) to apply changes to ${bundle}.`);
+    await reboot({ config, waitForBundle: bundle, deviceSerial, abortSignal: opts.abortSignal, logger: opts.logger });
+    postInstallPid = await pidOf(config, bundle, deviceSerial);
+    method = "reboot";
+    cacheCleared = rebootDecision.reason === "asset-cache";
+  }
+  return { method, preInstallPid, postInstallPid, replaced: installMethod === "replace", cacheCleared };
+}
+
 // src/index.ts
-var VERSION = "0.6.1";
+var VERSION = "0.7.0";
 export {
   ALL_SDKS,
   APL_VALUES,
@@ -1678,32 +3010,59 @@ export {
   CancelledError,
   ChecksumMismatchError,
   CmdToolsNotInstalledError,
+  CommandFailedError,
   OHOS_URL_BASE,
   OniroError,
   SdkNotInstalledError,
   UnsupportedPlatformError,
   VERSION,
+  applyChanges,
   attemptHdcConnection,
+  buildGestureCommands,
+  buildHap,
+  buildHvigorwArgs,
+  buildInputCommand,
+  buildRawTouchCommand,
+  captureBurst,
   consoleLogger,
   createMaterial,
   createScaffold,
+  decideInstallMethod,
+  decideReboot,
   decryptPwd,
+  dedupEntries,
   defaultContext,
   defaultPaths,
+  detectAaStartFailure,
   detectProjectSdkVersion,
+  detectSigningConfigNames,
+  diffEntryNames,
+  diffHapAssets,
+  discoverHaps,
   downloadAndInstallSdk,
   downloadFile,
+  dumpLayout,
+  dumpLog,
+  dumpRenderService,
+  dumpScreen,
+  dumpWindow,
   encryptPwd,
+  ensureOhModules,
+  ensureOk,
   extractTarball,
   extractZipWithProgress,
   findAppProcessId,
   findCmdToolsSourceDir,
+  findRunningProcess,
+  forceStop,
   generateSigningConfigs,
   getBundleName,
   getCmdToolsBin,
   getCmdToolsDownloadUrl,
   getCmdToolsPath,
   getCmdToolsStatus,
+  getDeviceInfo,
+  getDisplaySize,
   getEmulatorDir,
   getHdcPath,
   getHvigorwPath,
@@ -1711,10 +3070,12 @@ export {
   getKey,
   getMainAbility,
   getOhosBaseSdkHome,
+  getOhpmPath,
   getOsFolder,
   getSdkFilename,
   getSdkRootDir,
   getSupportedSdksForUi,
+  hdcExec,
   installApp,
   installCmdTools,
   installEmulator,
@@ -1723,25 +3084,55 @@ export {
   isValidBundleName,
   isValidProjectName,
   launchApp,
+  listAbilities,
+  listDevices,
+  listModules,
   listRunningProcesses,
   listTemplates,
   nonInteractivePrompter,
   noopLogger,
   noopProgress,
+  paramGet,
+  paramSet,
+  parseBounds,
+  parseCodelinterFindings,
+  parseDeviceList,
   parseHilogLine,
+  pickSigningKind,
+  prepareSigning,
+  pruneLayout,
   readJson5File,
   readJsonFile,
+  reboot,
+  recvFile,
   removeCmdTools,
   removeEmulator,
   removeSdk,
+  runCodelinter,
   runHvigorw,
+  runOhpm,
+  runProcess,
+  scopedLogger,
+  selectDevice,
+  sendFile,
+  sendGesture,
+  sendInput,
+  sendRawTouch,
   setHilogLevel,
+  shell,
   startEmulator,
   staticConfig,
   stopEmulator,
   streamHilog,
+  takeScreenshot,
+  uninstallApp,
   validateTemplateLayout,
   verifySha256,
+  waitForBoot,
+  waitForBundle,
+  waitForCondition,
+  waitForLog,
+  watchLog,
   writeJson5File,
   writeJsonFile
 };