@oniroproject/core 0.6.0

package/dist/index.js

@@ -0,0 +1,1748 @@
+// src/ports/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+var consoleLogger = {
+  debug: (m) => console.debug(m),
+  info: (m) => console.log(m),
+  warn: (m) => console.warn(m),
+  error: (m) => console.error(m)
+};
+
+// src/ports/progress.ts
+var noopProgress = {
+  report() {
+  }
+};
+
+// src/ports/config.ts
+import * as os from "os";
+import * as path from "path";
+var defaultPaths = {
+  sdkRootDir: () => path.join(os.homedir(), "setup-ohos-sdk"),
+  cmdToolsPath: () => path.join(os.homedir(), "command-line-tools"),
+  emulatorDir: () => path.join(os.homedir(), "oniro-emulator"),
+  hapPath: "entry/build/default/outputs/default/entry-default-signed.hap",
+  emulatorUrl: "https://github.com/eclipse-oniro4openharmony/device_board_oniro/releases/latest/download/oniro_emulator.zip",
+  // The Huawei mirror only hosts a public Linux build of the command-line tools.
+  // Windows and macOS require a manual download from the Huawei developer portal
+  // (https://developer.huawei.com/...); pass the resulting ZIP to `cmdtools install --from-zip <path>`
+  // or set ONIRO_CMD_TOOLS_URL_WINDOWS / ONIRO_CMD_TOOLS_URL_MAC to a self-hosted URL.
+  cmdToolsUrlLinux: "https://repo.huaweicloud.com/harmonyos/ohpm/5.1.0/commandline-tools-linux-x64-5.1.0.840.zip"
+};
+function staticConfig(values = {}) {
+  return {
+    get(key, fallback) {
+      const v = values[key];
+      if (v === void 0 || v === "") {
+        return fallback;
+      }
+      if (typeof v === "string" && v.includes("${userHome}")) {
+        return v.replace(/\$\{userHome\}/g, os.homedir());
+      }
+      return v;
+    }
+  };
+}
+
+// src/ports/prompter.ts
+var nonInteractivePrompter = {
+  async confirm(message) {
+    throw new Error(`Non-interactive mode: cannot confirm "${message}"`);
+  },
+  async input(message) {
+    throw new Error(`Non-interactive mode: cannot ask "${message}"`);
+  },
+  async selectDirectory(message) {
+    throw new Error(`Non-interactive mode: cannot prompt for directory "${message}"`);
+  },
+  async selectFile(message) {
+    throw new Error(`Non-interactive mode: cannot prompt for file "${message}"`);
+  }
+};
+
+// src/ports/errors.ts
+var OniroError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "OniroError";
+  }
+  cause;
+};
+var SdkNotInstalledError = class extends OniroError {
+  constructor(api, expectedPath) {
+    super(`SDK API ${api} is not installed at ${expectedPath}.`);
+    this.api = api;
+    this.expectedPath = expectedPath;
+    this.name = "SdkNotInstalledError";
+  }
+  api;
+  expectedPath;
+};
+var CmdToolsNotInstalledError = class extends OniroError {
+  constructor(expectedPath) {
+    super(`OpenHarmony command-line tools are not installed at ${expectedPath}.`);
+    this.expectedPath = expectedPath;
+    this.name = "CmdToolsNotInstalledError";
+  }
+  expectedPath;
+};
+var UnsupportedPlatformError = class extends OniroError {
+  constructor(platform6) {
+    super(`Unsupported platform: ${platform6}.`);
+    this.platform = platform6;
+    this.name = "UnsupportedPlatformError";
+  }
+  platform;
+};
+var ChecksumMismatchError = class extends OniroError {
+  constructor(expected, actual) {
+    super(`SHA256 mismatch: expected ${expected}, got ${actual}.`);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "ChecksumMismatchError";
+  }
+  expected;
+  actual;
+};
+var CancelledError = class extends OniroError {
+  constructor(message = "Operation cancelled.") {
+    super(message);
+    this.name = "CancelledError";
+  }
+};
+
+// src/ports/context.ts
+function defaultContext(overrides = {}) {
+  return {
+    logger: overrides.logger ?? noopLogger,
+    config: overrides.config ?? staticConfig()
+  };
+}
+
+// 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" }
+];
+var OHOS_URL_BASE = "https://repo.huaweicloud.com/openharmony/os";
+
+// src/sdk/platform.ts
+import * as os2 from "os";
+function getOsFolder() {
+  const platform6 = os2.platform();
+  if (platform6 === "linux") return "linux";
+  if (platform6 === "darwin") return "darwin";
+  if (platform6 === "win32") return "windows";
+  throw new UnsupportedPlatformError(platform6);
+}
+function getSdkFilename(version) {
+  const platform6 = os2.platform();
+  const v = version ?? ALL_SDKS[ALL_SDKS.length - 1].version;
+  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 };
+  }
+  if (platform6 === "darwin") {
+    if (os2.arch() === "arm64") {
+      return { filename: "L2-SDK-MAC-M1-PUBLIC.tar.gz", osFolder: "darwin", strip: 3 };
+    }
+    return { filename: "ohos-sdk-mac-public.tar.gz", osFolder: "darwin", strip: 3 };
+  }
+  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 };
+  }
+  throw new UnsupportedPlatformError(platform6);
+}
+
+// src/sdk/paths.ts
+import * as fs from "fs";
+import * as os3 from "os";
+import * as path2 from "path";
+function getSdkRootDir(config) {
+  return config.get("sdkRootDir", defaultPaths.sdkRootDir());
+}
+function getOhosBaseSdkHome(config) {
+  return path2.join(getSdkRootDir(config), getOsFolder());
+}
+function getCmdToolsPath(config) {
+  return config.get("cmdToolsPath", defaultPaths.cmdToolsPath());
+}
+function getEmulatorDir(config) {
+  return config.get("emulatorDir", defaultPaths.emulatorDir());
+}
+function pickExisting(candidates) {
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function getCmdToolsBin(config) {
+  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")
+    ]);
+  }
+  return path2.join(binDir, "ohpm");
+}
+function getHdcPath(config) {
+  const base = path2.join(getCmdToolsPath(config), "sdk", "default", "openharmony", "toolchains");
+  if (os3.platform() === "win32") {
+    return pickExisting([
+      path2.join(base, "hdc.exe"),
+      path2.join(base, "hdc.bat"),
+      path2.join(base, "hdc.cmd"),
+      path2.join(base, "hdc")
+    ]);
+  }
+  return path2.join(base, "hdc");
+}
+function getHvigorwPath(config, projectDir) {
+  const cmdToolsBin = path2.join(getCmdToolsPath(config), "bin");
+  return 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")
+  ]);
+}
+
+// src/sdk/detectProjectSdk.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import JSON5 from "json5";
+function detectProjectSdkVersion(projectRoot, logger = noopLogger) {
+  const buildProfilePath = path3.join(projectRoot, "build-profile.json5");
+  if (!fs2.existsSync(buildProfilePath)) {
+    logger.warn(`build-profile.json5 not found at ${projectRoot}`);
+    return void 0;
+  }
+  try {
+    const content = fs2.readFileSync(buildProfilePath, "utf-8");
+    const config = JSON5.parse(content);
+    const product = config.app?.products?.[0];
+    const v = product?.compileSdkVersion;
+    return typeof v === "number" ? v : void 0;
+  } catch (err) {
+    logger.error(`Error reading build-profile.json5 at ${projectRoot}: ${String(err)}`);
+    return void 0;
+  }
+}
+
+// src/sdk/download.ts
+import * as fs3 from "fs";
+import * as crypto from "crypto";
+import { pipeline } from "stream";
+import { promisify } from "util";
+import followRedirects from "follow-redirects";
+var { http, https } = followRedirects;
+var pipelineAsync = promisify(pipeline);
+async function downloadFile(opts) {
+  const { url, dest, progress, abortSignal } = opts;
+  const proto = url.startsWith("https") ? https : http;
+  return new Promise((resolve2, reject) => {
+    const s = Math.max(0, Math.min(100, opts.start ?? 0));
+    const r = Math.max(0, Math.min(100 - s, opts.range ?? 100));
+    let settled = false;
+    const done = (err) => {
+      if (settled) return;
+      settled = true;
+      err ? reject(err) : resolve2();
+    };
+    if (abortSignal?.aborted) {
+      done(new CancelledError("Download cancelled before start."));
+      return;
+    }
+    const file = fs3.createWriteStream(dest);
+    const req = proto.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        try {
+          response.destroy();
+        } catch {
+        }
+        try {
+          file.close();
+        } catch {
+        }
+        fs3.unlink(dest, () => {
+        });
+        done(new OniroError(`Failed to download '${url}' (HTTP ${response.statusCode})`));
+        return;
+      }
+      const total = parseInt(response.headers["content-length"] || "0", 10);
+      let downloaded = 0;
+      let lastOverall = Math.round(s);
+      response.on("data", (chunk) => {
+        downloaded += chunk.length;
+        if (progress && total) {
+          const localPercent = Math.min(100, Math.round(downloaded / total * 100));
+          const overall = Math.min(100, Math.round(s + downloaded / total * r));
+          const inc = overall - lastOverall;
+          if (inc > 0) {
+            progress.report({ message: `Downloading: ${localPercent}%`, increment: inc });
+            lastOverall = overall;
+          } else {
+            progress.report({ message: `Downloading: ${localPercent}%`, increment: 0 });
+          }
+        }
+      });
+      response.pipe(file);
+      file.on("finish", () => {
+        if (progress) {
+          const endOverall = Math.min(100, Math.round(s + r));
+          const inc = endOverall - lastOverall;
+          if (inc > 0) progress.report({ message: "Downloading: 100%", increment: inc });
+        }
+        file.close((err) => err ? done(err) : done());
+      });
+      abortSignal?.addEventListener("abort", () => {
+        response.destroy();
+        file.close();
+        fs3.unlink(dest, () => {
+        });
+        done(new CancelledError("Download cancelled."));
+      });
+    });
+    req.on("error", (err) => {
+      try {
+        file.close();
+      } catch {
+      }
+      fs3.unlink(dest, () => {
+      });
+      done(new OniroError(`Error downloading '${url}': ${err.message}`, err));
+    });
+    abortSignal?.addEventListener("abort", () => {
+      req.destroy();
+      file.close();
+      fs3.unlink(dest, () => {
+      });
+      done(new CancelledError("Download cancelled."));
+    });
+  });
+}
+async function verifySha256(filePath, sha256Path) {
+  const expected = fs3.readFileSync(sha256Path, "utf8").split(/\s+/)[0];
+  const hash = crypto.createHash("sha256");
+  await pipelineAsync(fs3.createReadStream(filePath), hash);
+  const actual = hash.digest("hex");
+  if (actual !== expected) {
+    throw new ChecksumMismatchError(expected, actual);
+  }
+}
+
+// src/sdk/extract.ts
+import * as fs4 from "fs";
+import * as os4 from "os";
+import * as path4 from "path";
+import { pipeline as pipeline2 } from "stream";
+import { promisify as promisify2 } from "util";
+import * as tar from "tar";
+import StreamZip from "node-stream-zip";
+var pipelineAsync2 = promisify2(pipeline2);
+async function extractZipWithProgress(opts) {
+  const { zipPath, dest, progress } = opts;
+  const logger = opts.logger ?? noopLogger;
+  const zip = new StreamZip.async({ file: zipPath });
+  const entries = await zip.entries();
+  const files = Object.values(entries);
+  const total = files.length || 1;
+  const s = Math.max(0, Math.min(100, opts.start ?? 0));
+  const r = Math.max(0, Math.min(100 - s, opts.range ?? 100));
+  let processed = 0;
+  let lastOverall = Math.round(s);
+  await fs4.promises.mkdir(dest, { recursive: true });
+  const destRoot = path4.resolve(dest);
+  const safeResolveTarget = (entryName) => {
+    const resolved = path4.resolve(destRoot, entryName);
+    const rel = path4.relative(destRoot, resolved);
+    if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+      throw new OniroError(`Blocked ZIP entry with illegal path: ${entryName}`);
+    }
+    return resolved;
+  };
+  try {
+    for (const file of files) {
+      const entryName = file.name;
+      const targetPath = safeResolveTarget(entryName);
+      const attr = file.attr ? file.attr >>> 16 : 0;
+      const isSymlink = "isSymbolicLink" in file ? Boolean(file.isSymbolicLink) : (attr & 61440) === 40960;
+      if (file.isDirectory) {
+        await fs4.promises.mkdir(targetPath, { recursive: true });
+      } else if (isSymlink) {
+        await fs4.promises.mkdir(path4.dirname(targetPath), { recursive: true });
+        const linkTargetBuffer = await zip.entryData(file);
+        const linkTarget = linkTargetBuffer.toString("utf8");
+        try {
+          const isWin = os4.platform() === "win32";
+          await fs4.promises.symlink(linkTarget, targetPath, isWin ? "file" : void 0);
+        } catch (e) {
+          logger.warn(`Failed to create symlink at ${targetPath}: ${String(e)}`);
+        }
+      } else {
+        await fs4.promises.mkdir(path4.dirname(targetPath), { recursive: true });
+        const readStream = await zip.stream(file);
+        const writeStream = fs4.createWriteStream(targetPath);
+        await pipelineAsync2(readStream, writeStream);
+        if (attr > 0) {
+          try {
+            await fs4.promises.chmod(targetPath, attr & 511);
+          } catch {
+          }
+        }
+      }
+      processed++;
+      if (progress) {
+        const localPercent = Math.min(100, Math.round(processed / total * 100));
+        const overall = Math.min(100, Math.round(s + processed / total * r));
+        const inc = overall - lastOverall;
+        if (inc > 0) {
+          progress.report({ message: `Extracting: ${localPercent}%`, increment: inc });
+          lastOverall = overall;
+        } else {
+          progress.report({ message: `Extracting: ${localPercent}%`, increment: 0 });
+        }
+      }
+    }
+  } finally {
+    await zip.close();
+  }
+  if (progress) {
+    const endOverall = Math.min(100, Math.round(s + r));
+    const inc = endOverall - lastOverall;
+    if (inc > 0) progress.report({ message: "Extracting: 100%", increment: inc });
+  }
+}
+async function extractTarball(tarPath, dest, strip = 0) {
+  await tar.x({ file: tarPath, cwd: dest, strip });
+}
+
+// src/sdk/list.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function getSupportedSdksForUi(config) {
+  const base = path5.join(getSdkRootDir(config), getOsFolder());
+  return ALL_SDKS.map((sdk) => ({
+    version: sdk.version,
+    api: sdk.api,
+    installed: fs5.existsSync(path5.join(base, sdk.api))
+  })).sort((a, b) => Number(b.api) - Number(a.api));
+}
+function getInstalledSdks(config) {
+  const sdkRoot = getSdkRootDir(config);
+  const versions = /* @__PURE__ */ new Set();
+  if (!fs5.existsSync(sdkRoot)) return [];
+  for (const osFolder of ["linux", "darwin", "windows"]) {
+    const osPath = path5.join(sdkRoot, osFolder);
+    if (!fs5.existsSync(osPath) || !fs5.statSync(osPath).isDirectory()) continue;
+    for (const api of fs5.readdirSync(osPath)) {
+      const apiPath = path5.join(osPath, api);
+      if (fs5.statSync(apiPath).isDirectory()) versions.add(api);
+    }
+  }
+  return ALL_SDKS.filter((sdk) => versions.has(sdk.api)).map((sdk) => sdk.version);
+}
+
+// src/sdk/remove.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+function removeSdk(config, api) {
+  const sdkRoot = getSdkRootDir(config);
+  let removed = false;
+  for (const osFolder of ["linux", "darwin", "windows"]) {
+    const sdkPath = path6.join(sdkRoot, osFolder, api);
+    if (fs6.existsSync(sdkPath)) {
+      fs6.rmSync(sdkPath, { recursive: true, force: true });
+      removed = true;
+    }
+  }
+  return removed;
+}
+
+// src/sdk/install.ts
+import * as fs7 from "fs";
+import * as os5 from "os";
+import * as path7 from "path";
+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 sha256Url = `${downloadUrl}.sha256`;
+  const tmpDir = fs7.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);
+  const sdkInstallDir = path7.join(getSdkRootDir(config), osFolder, api);
+  fs7.mkdirSync(path7.dirname(sdkInstallDir), { recursive: true });
+  const checkCancelled = () => {
+    if (abortSignal?.aborted) throw new CancelledError();
+  };
+  try {
+    progress?.report({ message: "Downloading SDK archive...", increment: 0 });
+    await downloadFile({ url: downloadUrl, dest: tarPath, progress, abortSignal, start: 0, range: 35 });
+    progress?.report({ message: "Downloading checksum...", increment: 0 });
+    await downloadFile({ url: sha256Url, dest: sha256Path, progress, abortSignal, start: 35, range: 10 });
+    progress?.report({ message: "Verifying checksum...", increment: 0 });
+    await verifySha256(tarPath, sha256Path);
+    progress?.report({ message: "Verifying checksum...", increment: 5 });
+    checkCancelled();
+    progress?.report({ message: "Extracting SDK (this may take a while)...", increment: 0 });
+    await extractTarball(tarPath, extractDir, strip);
+    progress?.report({ message: "Extracting SDK (this may take a while)...", increment: 10 });
+    checkCancelled();
+    const osContentPath = path7.join(extractDir, osFolder);
+    if (!fs7.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 componentsStart = 60;
+    const componentsBudget = 35;
+    const n = zipFiles.length;
+    if (n === 0) {
+      progress?.report({ message: "No SDK component ZIPs found.", increment: componentsBudget });
+    } else {
+      progress?.report({ message: "Extracting SDK components...", increment: 0 });
+    }
+    const base = n > 0 ? Math.floor(componentsBudget / n) : 0;
+    let rem = n > 0 ? componentsBudget % n : 0;
+    let cursor = componentsStart;
+    for (const zipFile of zipFiles) {
+      checkCancelled();
+      logger.info(`Extracting component ${zipFile}`);
+      const zipPath = path7.join(osContentPath, zipFile);
+      const thisBudget = base + (rem > 0 ? 1 : 0);
+      if (rem > 0) rem--;
+      await extractZipWithProgress({ zipPath, dest: osContentPath, progress, start: cursor, range: thisBudget, logger });
+      cursor += thisBudget;
+      fs7.unlinkSync(zipPath);
+    }
+    progress?.report({ message: "Finalizing installation...", increment: 0 });
+    if (fs7.existsSync(sdkInstallDir)) {
+      fs7.rmSync(sdkInstallDir, { recursive: true, force: true });
+    }
+    fs7.renameSync(osContentPath, sdkInstallDir);
+    progress?.report({ message: "Finalizing installation...", increment: 3 });
+    progress?.report({ message: "Cleaning up...", increment: 0 });
+    fs7.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 });
+    throw err;
+  }
+}
+
+// src/cmdTools/install.ts
+import * as fs8 from "fs";
+import * as os6 from "os";
+import * as path8 from "path";
+import { execFileSync } from "child_process";
+function getCmdToolsDownloadUrl(config, platform6 = os6.platform()) {
+  if (platform6 === "linux") {
+    return config.get("cmdToolsUrlLinux", defaultPaths.cmdToolsUrlLinux);
+  }
+  if (platform6 === "win32") {
+    const url = config.get("cmdToolsUrlWindows", "");
+    if (!url) {
+      throw new OniroError(
+        "No Windows command-line tools URL configured. The Huawei mirror does not host a public Windows build; download the ZIP from the Huawei developer portal and run `oniro-app cmdtools install --from-zip <path>`, or set ONIRO_CMD_TOOLS_URL_WINDOWS to a self-hosted URL."
+      );
+    }
+    return url;
+  }
+  if (platform6 === "darwin") {
+    const url = config.get("cmdToolsUrlMac", "");
+    if (!url) {
+      throw new OniroError(
+        "No macOS command-line tools URL configured. The Huawei mirror does not host a public macOS build; download the ZIP from the Huawei developer portal and run `oniro-app cmdtools install --from-zip <path>`, or set ONIRO_CMD_TOOLS_URL_MAC to a self-hosted URL."
+      );
+    }
+    return url;
+  }
+  throw new UnsupportedPlatformError(platform6);
+}
+function findCmdToolsSourceDir(extractPath) {
+  const known = [
+    path8.join(extractPath, "command-line-tools"),
+    path8.join(extractPath, "oh-command-line-tools"),
+    path8.join(extractPath, "commandline-tools")
+  ];
+  for (const c of known) {
+    if (fs8.existsSync(c)) return c;
+  }
+  const entries = fs8.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;
+  }
+  throw new OniroError("Could not locate command line tools folder in the extracted archive.");
+}
+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 zipPath = opts.localZipPath ?? path8.join(tmpDir, "oh-command-line-tools.zip");
+  const extractPath = path8.join(tmpDir, "oh-command-line-tools");
+  try {
+    if (!opts.localZipPath) {
+      const url = getCmdToolsDownloadUrl(config);
+      progress?.report({ message: "Downloading command line tools...", increment: 0 });
+      await downloadFile({ url, dest: zipPath, progress, abortSignal, start: 0, range: 50 });
+    }
+    progress?.report({ message: "Extracting tools...", increment: 0 });
+    await extractZipWithProgress({ zipPath, dest: extractPath, progress, start: 50, range: 45, logger });
+    fs8.mkdirSync(CMD_PATH, { recursive: true });
+    const srcDir = findCmdToolsSourceDir(extractPath);
+    for (const entry of fs8.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);
+      } else {
+        fs8.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);
+      }
+    }
+    progress?.report({ message: "Finalizing installation...", increment: 5 });
+    progress?.report({ message: "Cleaning up...", increment: 0 });
+  } finally {
+    fs8.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));
+  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");
+      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()})` };
+      }
+    }
+  } catch {
+  }
+  try {
+    const version = execFileSync(bin, ["-v"], { encoding: "utf8" }).trim();
+    return { installed: true, status: `Installed (${version})` };
+  } catch {
+    return { installed: true, status: "Installed (version unknown)" };
+  }
+}
+function isCmdToolsInstalled(config) {
+  return getCmdToolsStatus(config).installed;
+}
+function removeCmdTools(config) {
+  const cmdPath = getCmdToolsPath(config);
+  if (fs8.existsSync(cmdPath)) {
+    fs8.rmSync(cmdPath, { recursive: true, force: true });
+  }
+}
+
+// src/sign/encryptKey.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import * as crypto2 from "crypto";
+var DAEMON_ROOT_KEY_COMPONENT_LENGTH = 16;
+var DAEMON_SALT_KEY_LENGTH = 16;
+var DAEMON_WORK_KEY_LENGTH = 16;
+var KEY_FILE_DIRECTORY_PERMISSIONS = 493;
+var KEY_FILE_PERMISSIONS = 384;
+var COMPONENT = Buffer.from([
+  49,
+  243,
+  9,
+  115,
+  214,
+  175,
+  91,
+  184,
+  211,
+  190,
+  177,
+  88,
+  101,
+  131,
+  192,
+  119
+]);
+function encrypt(key, data) {
+  const iv = crypto2.randomBytes(12);
+  const cipher = crypto2.createCipheriv("aes-128-gcm", key, iv);
+  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  const totalLength = ciphertext.length + authTag.length;
+  const out = Buffer.alloc(4 + iv.length + ciphertext.length + authTag.length);
+  out.writeUInt32BE(totalLength, 0);
+  iv.copy(out, 4);
+  ciphertext.copy(out, 16);
+  authTag.copy(out, 16 + ciphertext.length);
+  return out;
+}
+function decrypt(key, data) {
+  const totalLength = data.readUInt32BE(0);
+  const iv = data.subarray(4, 16);
+  const ciphertextLength = totalLength - 16;
+  const ciphertext = data.subarray(16, 16 + ciphertextLength);
+  const authTag = data.subarray(16 + ciphertextLength);
+  const decipher = crypto2.createDecipheriv("aes-128-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function xorBuffers(buffers) {
+  if (buffers.length === 0) {
+    throw new Error("No buffers provided for XOR.");
+  }
+  const result = Buffer.from(buffers[0]);
+  for (let i = 1; i < buffers.length; i++) {
+    const buf = buffers[i];
+    if (buf.length !== result.length) {
+      throw new Error("Buffers have different lengths in XOR.");
+    }
+    for (let j = 0; j < result.length; j++) {
+      result[j] = result[j] ^ buf[j];
+    }
+  }
+  return result;
+}
+function getRootKey(fdComponents, salt) {
+  const components = fdComponents.concat([COMPONENT]);
+  const xored = xorBuffers(components);
+  return crypto2.pbkdf2Sync(xored.toString(), salt, 1e4, 16, "sha256");
+}
+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);
+  return key;
+}
+function createAndStoreEnKey(rootKey, ceDir) {
+  const workKey = crypto2.randomBytes(DAEMON_WORK_KEY_LENGTH);
+  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);
+}
+function createMaterial(materialPath) {
+  fs9.mkdirSync(materialPath, { recursive: true });
+  fs9.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 });
+  const fdSubDirs = ["0", "1", "2"];
+  const fdComponents = [];
+  for (const sub of fdSubDirs) {
+    const subDir = path9.join(fdDir, sub);
+    fs9.mkdirSync(subDir, { recursive: true });
+    const comp = createAndStoreKey(subDir, DAEMON_ROOT_KEY_COMPONENT_LENGTH);
+    fdComponents.push(comp);
+  }
+  const salt = createAndStoreKey(acDir, DAEMON_SALT_KEY_LENGTH);
+  const rootKey = getRootKey(fdComponents, salt);
+  createAndStoreEnKey(rootKey, ceDir);
+}
+function readSingleFile(dir) {
+  if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
+    throw new Error(`Missing signing material directory: ${dir}`);
+  }
+  const files = fs9.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]));
+}
+function getKey(materialPath) {
+  if (!fs9.existsSync(materialPath) || !fs9.statSync(materialPath).isDirectory()) {
+    throw new Error("Material directory does not exist.");
+  }
+  const fdDir = path9.join(materialPath, "fd");
+  const fdComponents = ["0", "1", "2"].map((sub) => readSingleFile(path9.join(fdDir, sub)));
+  const salt = readSingleFile(path9.join(materialPath, "ac"));
+  const rootKey = getRootKey(fdComponents, salt);
+  const workMaterial = readSingleFile(path9.join(materialPath, "ce"));
+  return decrypt(rootKey, workMaterial);
+}
+function encryptPwd(password, materialPath) {
+  const key = getKey(materialPath);
+  const pwdBuffer = Buffer.from(password, "utf-8");
+  return encrypt(key, pwdBuffer).toString("hex");
+}
+function decryptPwd(encryptedHex, materialPath) {
+  const key = getKey(materialPath);
+  const encryptedBuffer = Buffer.from(encryptedHex, "hex");
+  return decrypt(key, encryptedBuffer).toString("utf-8");
+}
+
+// src/sign/generateSigningConfigs.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import JSON52 from "json5";
+var APL_VALUES = ["normal", "system_basic", "system_core"];
+var APP_FEATURE_VALUES = ["hos_normal_app", "hos_system_app"];
+function copyFilesToProject(projectDir, paths, logger) {
+  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"));
+}
+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})...`);
+  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)) {
+    throw new OniroError(`${appJsonPath} does not exist.`);
+  }
+  let appJson;
+  try {
+    appJson = JSON52.parse(fs10.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"));
+  } catch (e) {
+    throw new OniroError(`Error parsing ${profileTemplatePath}: ${e.message}`, e);
+  }
+  if (!appJson.app?.bundleName) {
+    throw new OniroError("app.json5 does not contain app.bundleName.");
+  }
+  if (!profileTemplate["bundle-info"]) {
+    throw new OniroError("UnsgnedReleasedProfileTemplate.json is missing the bundle-info section.");
+  }
+  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 thirdCert = certs[2].trim() + "\n-----END CERTIFICATE-----\n";
+  profileTemplate["bundle-info"]["distribution-certificate"] = thirdCert;
+  fs10.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
+}
+function generateP7bFile(projectDir, paths, logger) {
+  logger.info("[sign] Generating P7b profile via hap-sign-tool...");
+  const signaturesDir = path10.join(projectDir, "signatures");
+  const profileTemplatePath = path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json");
+  const outputProfilePath = path10.join(signaturesDir, "app1-profile.p7b");
+  const args = [
+    "-jar",
+    paths.signTool,
+    "sign-profile",
+    "-keyAlias",
+    "openharmony application profile release",
+    "-signAlg",
+    "SHA256withECDSA",
+    "-mode",
+    "localSign",
+    "-profileCertFile",
+    paths.profileCert,
+    "-inFile",
+    profileTemplatePath,
+    "-keystoreFile",
+    paths.keystore,
+    "-outFile",
+    outputProfilePath,
+    "-keyPwd",
+    "123456",
+    "-keystorePwd",
+    "123456"
+  ];
+  try {
+    execFileSync2("java", args, { stdio: "inherit" });
+  } catch (e) {
+    throw new OniroError(
+      `hap-sign-tool failed. Ensure a JDK (with keytool/java) is on PATH. Underlying error: ${e.message}`,
+      e
+    );
+  }
+}
+function updateBuildProfile(projectDir, logger) {
+  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);
+  let buildProfile = { app: {} };
+  if (fs10.existsSync(buildProfilePath)) {
+    try {
+      buildProfile = JSON52.parse(fs10.readFileSync(buildProfilePath, "utf-8"));
+    } catch (e) {
+      throw new OniroError(`Error parsing ${buildProfilePath}: ${e.message}`, e);
+    }
+  }
+  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"
+      }
+    }
+  ];
+  fs10.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 });
+  }
+  createMaterial(materialDir);
+}
+function generateSigningConfigs(options) {
+  const { projectDir, sdkHome } = options;
+  const logger = options.logger ?? noopLogger;
+  const apl = options.apl ?? "normal";
+  if (!APL_VALUES.includes(apl)) {
+    throw new OniroError(`Invalid apl '${apl}'. Expected one of: ${APL_VALUES.join(", ")}.`);
+  }
+  const appFeature = resolveAppFeature(apl, options.appFeature);
+  if (!APP_FEATURE_VALUES.includes(appFeature)) {
+    throw new OniroError(
+      `Invalid appFeature '${appFeature}'. Expected one of: ${APP_FEATURE_VALUES.join(", ")}.`
+    );
+  }
+  const sdkVersion = detectProjectSdkVersion(projectDir, logger);
+  if (!sdkVersion) {
+    throw new OniroError(
+      "Could not detect project SDK version (compileSdkVersion missing in build-profile.json5)."
+    );
+  }
+  const sdkPath = path10.join(sdkHome, String(sdkVersion));
+  if (!fs10.existsSync(sdkPath)) {
+    throw new OniroError(`SDK path does not exist: ${sdkPath}`);
+  }
+  const paths = {
+    signTool: path10.join(sdkPath, "toolchains/lib/hap-sign-tool.jar"),
+    keystore: path10.join(sdkPath, "toolchains/lib/OpenHarmony.p12"),
+    profileCert: path10.join(sdkPath, "toolchains/lib/OpenHarmonyProfileRelease.pem"),
+    unsignedProfileTemplate: path10.join(sdkPath, "toolchains/lib/UnsgnedReleasedProfileTemplate.json")
+  };
+  logger.info("[sign] Starting signing configuration generation...");
+  copyFilesToProject(projectDir, paths, logger);
+  modifyProfileTemplate(projectDir, apl, appFeature, logger);
+  generateP7bFile(projectDir, paths, logger);
+  prepareMaterialDirectory(projectDir, logger);
+  updateBuildProfile(projectDir, logger);
+  logger.info("[sign] Signing configuration generated successfully.");
+}
+
+// src/emulator/install.ts
+import * as fs11 from "fs";
+import * as os7 from "os";
+import * as path11 from "path";
+async function installEmulator(opts) {
+  const { config, progress, abortSignal } = 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 tmpZip = path11.join(tmpDir, "oniro_emulator.zip");
+  try {
+    fs11.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);
+    }
+    progress?.report({ message: "Finalizing installation...", increment: 5 });
+  } finally {
+    fs11.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function isEmulatorInstalled(config) {
+  return fs11.existsSync(path11.join(getEmulatorDir(config), "images", "run.sh"));
+}
+function removeEmulator(config) {
+  const emulatorDir = getEmulatorDir(config);
+  if (fs11.existsSync(emulatorDir)) {
+    fs11.rmSync(emulatorDir, { recursive: true, force: true });
+  }
+}
+
+// src/emulator/lifecycle.ts
+import * as fs12 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) {
+  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();
+      }
+    });
+  });
+}
+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);
+      });
+    });
+  } catch (err) {
+    logger.warn(`hdc connection attempt failed: ${err.message}`);
+    return false;
+  }
+}
+function resolveLauncher(imagesPath, headless, connect) {
+  const runSh = path12.join(imagesPath, "run.sh");
+  const runBat = path12.join(imagesPath, "run.bat");
+  const extra = [];
+  if (headless) extra.push("--headless");
+  if (connect) extra.push("--connect", connect);
+  if (os8.platform() === "win32") {
+    if (fs12.existsSync(runBat)) {
+      return { command: "cmd.exe", args: ["/c", runBat, ...extra], cwd: imagesPath };
+    }
+    if (fs12.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)) {
+    return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
+  }
+  if (fs12.existsSync(runBat)) {
+    return { command: "bash", args: [runBat, ...extra], cwd: imagesPath };
+  }
+  throw new OniroError(`No emulator launcher (run.sh or run.bat) found in ${imagesPath}.`);
+}
+async function startEmulator(opts) {
+  const { config } = opts;
+  const logger = opts.logger ?? noopLogger;
+  if (os8.platform() !== "win32" && fs12.existsSync(PID_FILE)) {
+    try {
+      const pid = Number(fs12.readFileSync(PID_FILE, "utf8").trim());
+      if (Number.isFinite(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+          logger.info(`Emulator already running (PID ${pid}); not starting another.`);
+          if (opts.waitForHdcSeconds && opts.waitForHdcSeconds > 0) {
+            await waitForHdc(config, opts.waitForHdcSeconds, opts.hdcPollIntervalMs ?? 5e3, logger, opts.abortSignal);
+          }
+          return;
+        } catch {
+        }
+      }
+    } catch (err) {
+      logger.warn(`Could not read PID file: ${err.message}`);
+    }
+  }
+  const imagesPath = path12.join(getEmulatorDir(config), "images");
+  if (!fs12.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");
+  let child;
+  try {
+    child = spawn(launcher.command, [...launcher.args], {
+      cwd: launcher.cwd,
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      windowsHide: true
+    });
+  } finally {
+    fs12.closeSync(logFd);
+  }
+  if (!child.pid) {
+    throw new OniroError(`Failed to spawn launcher (${launcher.command} ${launcher.args.join(" ")}).`);
+  }
+  fs12.writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+  logger.info(`Emulator launched (PID ${child.pid}). Logs: ${logPath}`);
+  const earlyExit = new Promise((resolve2) => {
+    child.once("exit", (code) => resolve2(code));
+    child.once("error", () => resolve2(-1));
+  });
+  const liveness = new Promise((resolve2) => setTimeout(() => resolve2("alive"), 2e3));
+  const outcome = await Promise.race([earlyExit, liveness]);
+  if (outcome !== "alive") {
+    const tail = readTail(logPath, 4e3);
+    throw new OniroError(
+      `Emulator launcher exited with code ${outcome} before reaching steady state. Tail of ${logPath}:
+${tail}`
+    );
+  }
+  if (opts.waitForHdcSeconds && opts.waitForHdcSeconds > 0) {
+    await waitForHdc(config, opts.waitForHdcSeconds, opts.hdcPollIntervalMs ?? 5e3, logger, opts.abortSignal, logPath);
+  }
+}
+async function waitForHdc(config, timeoutSeconds, pollIntervalMs, logger, abortSignal, logPathForDiagnostics) {
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  let attempt = 0;
+  while (Date.now() < deadline) {
+    if (abortSignal?.aborted) throw new CancelledError("hdc wait cancelled.");
+    attempt++;
+    if (await attemptHdcConnection(config, void 0, noopLogger)) {
+      logger.info(`hdc connected on attempt ${attempt}.`);
+      return;
+    }
+    if (attempt % 6 === 0) {
+      logger.info(`hdc not yet ready (attempt ${attempt}, ${Math.max(0, deadline - Date.now()) / 1e3 | 0}s remaining).`);
+      if (logPathForDiagnostics) {
+        const tail2 = readTail(logPathForDiagnostics, 1200);
+        if (tail2.trim()) logger.debug(`emulator log tail:
+${tail2}`);
+      }
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+  const tail = logPathForDiagnostics ? readTail(logPathForDiagnostics, 4e3) : "";
+  throw new OniroError(`hdc did not connect within ${timeoutSeconds}s.${tail ? `
+Tail of emulator log:
+${tail}` : ""}`);
+}
+function readTail(filePath, bytes) {
+  try {
+    const stat = fs12.statSync(filePath);
+    const start = Math.max(0, stat.size - bytes);
+    const fd = fs12.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(stat.size - start);
+      fs12.readSync(fd, buf, 0, buf.length, start);
+      return buf.toString("utf8");
+    } finally {
+      fs12.closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+async function stopEmulator(logger = noopLogger) {
+  if (fs12.existsSync(PID_FILE)) {
+    try {
+      const pid = Number(fs12.readFileSync(PID_FILE, "utf8").trim());
+      if (Number.isFinite(pid) && pid > 0) {
+        try {
+          process.kill(pid, "SIGTERM");
+          logger.info(`Sent SIGTERM to emulator PID ${pid}.`);
+        } catch (err) {
+          logger.warn(`Could not signal PID ${pid}: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      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";
+  try {
+    await execPromise(killCmd, void 0, logger);
+  } catch {
+  }
+  fs12.rm(PID_FILE, { force: true }, (err) => {
+    if (err) logger.warn(`Could not remove PID file: ${err.message}`);
+  });
+}
+
+// src/hdc/project.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+import JSON53 from "json5";
+function readJson5(filePath) {
+  const content = fs13.readFileSync(filePath, "utf-8");
+  return JSON53.parse(content);
+}
+function getBundleName(projectDir) {
+  const appJsonPath = path13.join(projectDir, "AppScope", "app.json5");
+  if (!fs13.existsSync(appJsonPath)) {
+    throw new OniroError(`Could not find app.json5 at ${appJsonPath}`);
+  }
+  const appJson = readJson5(appJsonPath);
+  if (!appJson.app?.bundleName) {
+    throw new OniroError("bundleName not found in app.json5");
+  }
+  return appJson.app.bundleName;
+}
+function getMainAbility(projectDir, moduleName = "entry") {
+  const moduleJsonPath = path13.join(projectDir, moduleName, "src", "main", "module.json5");
+  if (!fs13.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;
+}
+
+// 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 relativeHapPath = opts.hapPath ?? opts.config.get("hapPath", defaultPaths.hapPath);
+  const hapPath = path14.isAbsolute(relativeHapPath) ? relativeHapPath : path14.join(opts.projectDir, relativeHapPath);
+  if (!fs14.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);
+}
+async function launchApp(opts) {
+  const logger = opts.logger ?? noopLogger;
+  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);
+}
+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 processes = [];
+    let resolved = false;
+    proc.stdout.on("data", (data) => {
+      for (const line of data.toString().split("\n").filter(Boolean)) {
+        const match = line.match(/^(\d+)\s+(.+)$/);
+        if (!match) continue;
+        const pid = match[1];
+        const name = match[2];
+        processes.push({ pid, name });
+        if (options.targetProcessName && name === options.targetProcessName && !resolved) {
+          resolved = true;
+          proc.kill();
+          resolve2(pid);
+          return;
+        }
+      }
+    });
+    proc.stderr.on("data", (data) => {
+      logger.warn(`[hdc track-jpid] ${data.toString()}`);
+    });
+    proc.on("error", (err) => {
+      if (!resolved) {
+        resolved = true;
+        reject(err);
+      }
+    });
+    const timeout = setTimeout(() => {
+      if (resolved) return;
+      resolved = true;
+      proc.kill();
+      if (options.targetProcessName) {
+        reject(new OniroError(`Could not find process for bundle: ${options.targetProcessName}`));
+      } else {
+        resolve2(processes);
+      }
+    }, timeoutMs);
+    proc.on("close", () => {
+      clearTimeout(timeout);
+      if (resolved) return;
+      resolved = true;
+      if (options.targetProcessName) {
+        reject(new OniroError(`Could not find process for bundle: ${options.targetProcessName}`));
+      } else {
+        resolve2(processes);
+      }
+    });
+  });
+}
+async function findAppProcessId(config, projectDir, logger) {
+  const bundleName = getBundleName(projectDir);
+  const result = await listRunningProcesses(config, { targetProcessName: bundleName, logger });
+  return result;
+}
+
+// src/hdc/hilog.ts
+import { spawn as spawn3 } 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]);
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("error", (err) => {
+      logger.error(`[hilog] failed to spawn hdc: ${err.message}`);
+      reject(err);
+    });
+    child.once("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        const msg = stderr.trim() || `hdc shell hilog -b ${opts.level} exited with code ${code}`;
+        logger.error(`[hilog] ${msg}`);
+        reject(new Error(msg));
+      }
+    });
+  });
+}
+function streamHilog(opts) {
+  const hdc = getHdcPath(opts.config);
+  const args = ["shell", "hilog"];
+  if (opts.processId && opts.processId.trim() !== "") {
+    args.push("-P", opts.processId.trim());
+  }
+  return spawn3(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) {
+  const match = HILOG_LINE_RE.exec(line);
+  if (!match) return null;
+  return {
+    time: match[1],
+    pid: match[2],
+    tid: match[3],
+    level: match[4],
+    tag: match[5].trim(),
+    message: match[6]
+  };
+}
+
+// src/build/runHvigorw.ts
+import * as fs15 from "fs";
+import * as path15 from "path";
+import { spawn as spawn4 } from "child_process";
+function runHvigorw(opts) {
+  const { config, projectDir } = opts;
+  const logger = opts.logger ?? noopLogger;
+  if (!fs15.existsSync(path15.join(projectDir, "build-profile.json5"))) {
+    throw new OniroError(`Not an OpenHarmony project: ${projectDir} (build-profile.json5 not found).`);
+  }
+  if (!fs15.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);
+  if (process.platform !== "win32") {
+    try {
+      fs15.chmodSync(hvigorw, 493);
+    } catch {
+    }
+  }
+  const env = {
+    ...process.env,
+    OHOS_BASE_SDK_HOME: getOhosBaseSdkHome(config)
+  };
+  return new Promise((resolve2, reject) => {
+    logger.info(`[build] ${hvigorw} ${args.join(" ")}`);
+    const child = spawn4(hvigorw, args, { cwd: projectDir, env, shell: false });
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      opts.onOutput?.(text, "stdout");
+      logger.info(text.trimEnd());
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      opts.onOutput?.(text, "stderr");
+      logger.warn(text.trimEnd());
+    });
+    child.on("error", (err) => reject(new OniroError(`Failed to start hvigorw: ${err.message}`, err)));
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      if (exitCode === 0) resolve2({ exitCode });
+      else reject(new OniroError(`hvigorw exited with code ${exitCode}`));
+    });
+  });
+}
+
+// src/project/validators.ts
+function isValidProjectName(name) {
+  if (!name) return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  return /^[A-Za-z0-9._-]+$/.test(name);
+}
+function isValidBundleName(bundleName) {
+  return /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/.test(bundleName);
+}
+
+// src/project/templates.ts
+import * as fs16 from "fs";
+import * as path16 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 });
+  return entries.filter((e) => e.isDirectory()).map((e) => {
+    const dir = path16.join(templateRoot, e.name);
+    const metaPath = path16.join(dir, "template.json");
+    let meta = {};
+    if (fs16.existsSync(metaPath)) {
+      try {
+        meta = JSON.parse(fs16.readFileSync(metaPath, "utf8"));
+      } catch {
+      }
+    }
+    return {
+      id: e.name,
+      label: meta.label ?? toHumanTemplateName(e.name),
+      description: meta.description ?? "",
+      defaultModuleName: (meta.defaultModuleName ?? "entry").trim() || "entry"
+    };
+  }).sort((a, b) => a.label.localeCompare(b.label));
+}
+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"),
+    "hvigorfile.ts"
+  ];
+  return required.filter((rel) => !fs16.existsSync(path16.join(templateDir, rel)));
+}
+
+// src/project/createScaffold.ts
+import * as fs18 from "fs";
+import * as path17 from "path";
+
+// src/project/jsonHelpers.ts
+import * as fs17 from "fs";
+import JSON54 from "json5";
+function readJson5File(filePath) {
+  return JSON54.parse(fs17.readFileSync(filePath, "utf8"));
+}
+function writeJson5File(filePath, value) {
+  fs17.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function readJsonFile(filePath) {
+  return JSON.parse(fs17.readFileSync(filePath, "utf8"));
+}
+function writeJsonFile(filePath, value) {
+  fs17.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);
+    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 });
+  for (const entry of entries) {
+    const src = path17.join(srcDir, entry.name);
+    const dest = path17.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);
+    }
+  }
+}
+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 });
+    for (const entry of entries) {
+      const fullPath = path17.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".json5")) continue;
+      try {
+        const parsed = readJson5File(fullPath);
+        writeJson5File(fullPath, parsed);
+      } catch (err) {
+        logger.warn(`Failed to normalize ${fullPath}: ${String(err)}`);
+      }
+    }
+  }
+}
+function toJavaPropertiesPath(p) {
+  return process.platform === "win32" ? p.replace(/\\/g, "\\\\") : p;
+}
+function createOrUpdateLocalProperties(projectDir, sdkDir) {
+  const content = `sdk.dir=${toJavaPropertiesPath(sdkDir)}
+`;
+  fs18.writeFileSync(path17.join(projectDir, "local.properties"), content, "utf8");
+}
+function renameIfExists(fromPath, toPath) {
+  if (fs18.existsSync(fromPath) && fromPath !== toPath) {
+    fs18.renameSync(fromPath, toPath);
+  }
+}
+function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
+  const appJsonPath = path17.join(projectDir, "AppScope", "app.json5");
+  if (fs18.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 strings = readJsonFile(stringsPath);
+    if (Array.isArray(strings.string)) {
+      const appName = strings.string.find((s) => s.name === "app_name");
+      if (appName) appName.value = args.projectName;
+    }
+    writeJsonFile(stringsPath, strings);
+  }
+  const buildProfilePath = path17.join(projectDir, "build-profile.json5");
+  if (fs18.existsSync(buildProfilePath)) {
+    const buildProfile = readJson5File(buildProfilePath);
+    buildProfile.app = buildProfile.app ?? {};
+    if (Array.isArray(buildProfile.app.products) && buildProfile.app.products.length > 0) {
+      buildProfile.app.products[0].compileSdkVersion = args.sdkApi;
+      buildProfile.app.products[0].compatibleSdkVersion = args.sdkApi;
+    }
+    if (Array.isArray(buildProfile.modules) && buildProfile.modules.length > 0) {
+      buildProfile.modules[0].name = args.moduleName;
+      buildProfile.modules[0].srcPath = `./${args.moduleName}`;
+    }
+    writeJson5File(buildProfilePath, buildProfile);
+  }
+  const moduleJsonPath = path17.join(projectDir, args.moduleName, "src", "main", "module.json5");
+  if (fs18.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 pkg = readJson5File(moduleOhPackagePath);
+    pkg.name = args.moduleName;
+    writeJson5File(moduleOhPackagePath, pkg);
+  }
+  const vscodeDir = path17.join(projectDir, ".vscode");
+  fs18.mkdirSync(vscodeDir, { recursive: true });
+  const hapPath = `${args.moduleName}/build/default/outputs/default/${args.moduleName}-default-signed.hap`;
+  writeJsonFile(path17.join(vscodeDir, "settings.json"), {
+    "oniro.hapPath": hapPath,
+    "files.associations": { "*.json5": "jsonc" }
+  });
+  createOrUpdateLocalProperties(projectDir, sdkBaseDir);
+}
+async function createScaffold(opts) {
+  const logger = opts.logger ?? noopLogger;
+  if (!isValidProjectName(opts.projectName)) {
+    throw new OniroError(`Invalid project name '${opts.projectName}'. Use letters/numbers/._- and no slashes.`);
+  }
+  if (!isValidBundleName(opts.bundleName)) {
+    throw new OniroError(`Invalid bundle name '${opts.bundleName}'. Example: com.example.myapplication`);
+  }
+  if (!opts.location || !await pathExists(opts.location)) {
+    throw new OniroError(`Location does not exist: ${opts.location}`);
+  }
+  const templateDir = path17.join(opts.templateRoot, opts.templateId);
+  if (!await pathExists(templateDir)) {
+    throw new OniroError(`Template not found: ${templateDir}`);
+  }
+  const templates = listTemplates(opts.templateRoot);
+  const selected = templates.find((t) => t.id === opts.templateId);
+  const defaultModuleName = selected?.defaultModuleName ?? "entry";
+  const moduleName = (opts.moduleName ?? defaultModuleName).trim() || defaultModuleName;
+  const missing = validateTemplateLayout(templateDir, defaultModuleName);
+  if (missing.length > 0) {
+    throw new OniroError(`Template '${opts.templateId}' is missing required files:
+- ${missing.join("\n- ")}`);
+  }
+  const projectDir = path17.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 });
+  }
+  logger.info(`[create] Scaffolding ${opts.templateId} at ${projectDir}`);
+  await copyDirRecursive(templateDir, projectDir);
+  if (moduleName !== defaultModuleName) {
+    renameIfExists(path17.join(projectDir, defaultModuleName), path17.join(projectDir, moduleName));
+  }
+  updateTemplateConfigs(
+    projectDir,
+    {
+      projectName: opts.projectName,
+      bundleName: opts.bundleName,
+      sdkApi: opts.sdkApi,
+      moduleName
+    },
+    getOhosBaseSdkHome(opts.config)
+  );
+  await normalizeJson5ToJson(projectDir, logger);
+  return { projectDir };
+}
+
+// src/index.ts
+var VERSION = "0.6.0";
+export {
+  ALL_SDKS,
+  APL_VALUES,
+  APP_FEATURE_VALUES,
+  CancelledError,
+  ChecksumMismatchError,
+  CmdToolsNotInstalledError,
+  OHOS_URL_BASE,
+  OniroError,
+  SdkNotInstalledError,
+  UnsupportedPlatformError,
+  VERSION,
+  attemptHdcConnection,
+  consoleLogger,
+  createMaterial,
+  createScaffold,
+  decryptPwd,
+  defaultContext,
+  defaultPaths,
+  detectProjectSdkVersion,
+  downloadAndInstallSdk,
+  downloadFile,
+  encryptPwd,
+  extractTarball,
+  extractZipWithProgress,
+  findAppProcessId,
+  findCmdToolsSourceDir,
+  generateSigningConfigs,
+  getBundleName,
+  getCmdToolsBin,
+  getCmdToolsDownloadUrl,
+  getCmdToolsPath,
+  getCmdToolsStatus,
+  getEmulatorDir,
+  getHdcPath,
+  getHvigorwPath,
+  getInstalledSdks,
+  getKey,
+  getMainAbility,
+  getOhosBaseSdkHome,
+  getOsFolder,
+  getSdkFilename,
+  getSdkRootDir,
+  getSupportedSdksForUi,
+  installApp,
+  installCmdTools,
+  installEmulator,
+  isCmdToolsInstalled,
+  isEmulatorInstalled,
+  isValidBundleName,
+  isValidProjectName,
+  launchApp,
+  listRunningProcesses,
+  listTemplates,
+  nonInteractivePrompter,
+  noopLogger,
+  noopProgress,
+  parseHilogLine,
+  readJson5File,
+  readJsonFile,
+  removeCmdTools,
+  removeEmulator,
+  removeSdk,
+  runHvigorw,
+  setHilogLevel,
+  startEmulator,
+  staticConfig,
+  stopEmulator,
+  streamHilog,
+  validateTemplateLayout,
+  verifySha256,
+  writeJson5File,
+  writeJsonFile
+};
+//# sourceMappingURL=index.js.map