android2harmony 0.1.0

package/agents/scripts/hmos-precheck/arkts.mjs

@@ -0,0 +1,534 @@
+import { spawn } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+const CHECKER_SCRIPT = String.raw`
+'use strict';
+const fs = require('fs');
+const path = require('path');
+function parseArgs(argv) {
+  const args = { project: '', etsLoader: '', output: '', cacheDir: '', apiType: 'stageMode', compatibleSdkVersion: 12, permissions: [], hmsSdkEts: '', sysResourceFile: '', files: [] };
+  let i = 2;
+  while (i < argv.length) {
+    if (argv[i] === '--project' && argv[i + 1]) args.project = path.resolve(argv[++i]);
+    else if (argv[i] === '--ets-loader' && argv[i + 1]) args.etsLoader = path.resolve(argv[++i]);
+    else if (argv[i] === '--output' && argv[i + 1]) args.output = path.resolve(argv[++i]);
+    else if (argv[i] === '--cache-dir' && argv[i + 1]) args.cacheDir = path.resolve(argv[++i]);
+    else if (argv[i] === '--api-type' && argv[i + 1]) args.apiType = argv[++i];
+    else if (argv[i] === '--compatible-sdk-version' && argv[i + 1]) args.compatibleSdkVersion = Number.parseInt(argv[++i], 10);
+    else if (argv[i] === '--permission' && argv[i + 1]) args.permissions.push(argv[++i]);
+    else if (argv[i] === '--hms-sdk-ets' && argv[i + 1]) args.hmsSdkEts = path.resolve(argv[++i]);
+    else if (argv[i] === '--sys-resource-file' && argv[i + 1]) args.sysResourceFile = path.resolve(argv[++i]);
+    else if (argv[i] === '--files') {
+      i++;
+      while (i < argv.length && !argv[i].startsWith('--')) args.files.push(argv[i++]);
+      continue;
+    }
+    i++;
+  }
+  return args;
+}
+function parseDiagnosticLine(line) {
+  const match = line.match(/ArkTS:(ERROR|WARN)\s+File:\s+(.+?):(\d+):(\d+)/);
+  if (!match) return null;
+  return { severity: match[1].toLowerCase() === 'error' ? 'error' : 'warning', file: match[2], line: Number.parseInt(match[3], 10), column: Number.parseInt(match[4], 10) };
+}
+function parseMessageLine(line) {
+  const trimmed = line.trim();
+  const match = trimmed.match(/^(.+?)\s*\(([@a-z][\w./-]*)\)\s*$/i);
+  if (!match) return { message: trimmed, rule: '' };
+  return { message: match[1].trim(), rule: match[2] };
+}
+function moduleJsonPath(project) {
+  const candidates = [path.join(project, 'entry', 'src', 'main', 'module.json5'), path.join(project, 'src', 'main', 'module.json5'), path.join(project, 'entry', 'module.json5')];
+  for (const candidate of candidates) if (fs.existsSync(candidate)) return candidate;
+  return path.join(project, 'entry', 'src', 'main', 'module.json5');
+}
+function loadSystemResourceNames(resourceFile) {
+  if (!resourceFile || !fs.existsSync(resourceFile)) return null;
+  const names = new Set();
+  const content = fs.readFileSync(resourceFile, 'utf-8');
+  const linePattern = /^id:\d+,\s*'[^']*'\s+'([^']+)'/;
+  for (const line of content.split('\n')) {
+    const match = line.match(linePattern);
+    if (match) names.add(match[1]);
+  }
+  return names;
+}
+function validateSystemResources(files, resourceFile, project) {
+  const validNames = loadSystemResourceNames(resourceFile);
+  if (!validNames) return [];
+  const diagnostics = [];
+  const refPattern = /\$r\(\s*['"]sys\.(media|symbol)\.([^'"]+)['"]\s*\)/g;
+  for (const filePath of files) {
+    if (!fs.existsSync(filePath)) continue;
+    const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      refPattern.lastIndex = 0;
+      let match;
+      while ((match = refPattern.exec(lines[i])) !== null) {
+        const name = match[2];
+        if (!validNames.has(name)) diagnostics.push({ file: path.relative(project, filePath), line: i + 1, column: match.index + 1, severity: 'error', message: "Unknown system resource '" + name + "' for sys." + match[1], rule: 'resource-name-check' });
+      }
+    }
+  }
+  return diagnostics;
+}
+function main() {
+  const args = parseArgs(process.argv);
+  const captured = [];
+  const capture = (...items) => { captured.push(items.map(String).join(' ')); };
+  const origLog = console.log;
+  const origError = console.error;
+  const origWarn = console.warn;
+  try {
+    if (args.hmsSdkEts && fs.existsSync(args.hmsSdkEts)) {
+      const existing = process.env.externalApiPaths || '';
+      process.env.externalApiPaths = existing ? existing + path.delimiter + args.hmsSdkEts : args.hmsSdkEts;
+    }
+    const etsChecker = require(path.join(args.etsLoader, 'lib', 'ets_checker.js'));
+    const mainModule = require(path.join(args.etsLoader, 'main.js'));
+    Object.assign(mainModule.partialUpdateConfig, { executeArkTSLinter: true, standardArkTSLinter: true });
+    const fileMap = {};
+    args.files.forEach((file, index) => { fileMap["file_" + index] = path.isAbsolute(file) ? file : path.resolve(args.project, file); });
+    const projectConfig = {
+      projectPath: args.project,
+      projectRootPath: args.project,
+      modulePath: path.join(args.project, 'entry'),
+      moduleRootPath: path.join(args.project, 'entry'),
+      cachePath: args.cacheDir || path.join(args.project, '.cache', 'arkts-check'),
+      aceModuleJsonPath: moduleJsonPath(args.project),
+      compileMode: 'esmodule',
+      etsLoaderPath: args.etsLoader,
+      packageManagerType: 'ohpm',
+      packageDir: 'oh_modules',
+      runtimeOS: 'OpenHarmony',
+      sdkInfo: '5.0.0',
+      compatibleSdkVersion: Number.isFinite(args.compatibleSdkVersion) ? args.compatibleSdkVersion : 12,
+      compatibleSdkVersionStage: Number.isFinite(args.compatibleSdkVersion) ? args.compatibleSdkVersion : 12,
+      apiType: args.apiType,
+      permissions: args.permissions,
+      bundleType: '',
+      compilerTypes: [],
+      resolveModulePaths: [],
+    };
+    fs.mkdirSync(projectConfig.cachePath, { recursive: true });
+    if (args.apiType === 'stageMode') {
+      process.env.compileMode = 'moduleJson';
+      process.env.aceModuleJsonPath = projectConfig.aceModuleJsonPath;
+    }
+    console.log = capture; console.error = capture; console.warn = capture;
+    const logger = { debug: capture, info: capture, warn: capture, error: capture };
+    etsChecker.etsStandaloneChecker(fileMap, logger, projectConfig);
+  } catch (error) {
+    captured.push("Internal error: " + (error && error.message ? error.message : String(error)));
+  } finally {
+    console.log = origLog; console.error = origError; console.warn = origWarn;
+  }
+  const diagnostics = [];
+  let current = null;
+  const lines = captured.flatMap((entry) => entry.split('\n'));
+  for (const raw of lines) {
+    const line = raw.replace(/\x1b\[[0-9;]*m/g, '');
+    const loc = parseDiagnosticLine(line);
+    if (loc) { current = loc; continue; }
+    if (current && line.trim() && !line.includes('ArkTS:') && !line.includes('For details about')) {
+      const message = parseMessageLine(line);
+      diagnostics.push({ file: path.relative(args.project, current.file), line: current.line, column: current.column, severity: current.severity, message: message.message, rule: message.rule });
+      current = null;
+    }
+  }
+  const selectedFiles = args.files.map((file) => path.isAbsolute(file) ? file : path.resolve(args.project, file));
+  diagnostics.push(...validateSystemResources(selectedFiles, args.sysResourceFile, args.project));
+  const errorCount = diagnostics.filter((item) => item.severity === 'error').length;
+  const warnCount = diagnostics.filter((item) => item.severity === 'warning').length;
+  const payload = { tool_status: captured.some((line) => line.startsWith('Internal error:')) ? 'internal_error' : 'ok', success: errorCount === 0, errors: diagnostics, summary: { errorCount, warnCount }, raw_tail: captured.slice(-20) };
+  const rendered = JSON.stringify(payload, null, 2);
+  if (args.output) fs.writeFileSync(args.output, rendered + '\n');
+  process.stdout.write('\n__ARKTS_PRECHECK_JSON_START__\n');
+  process.stdout.write(rendered);
+  process.stdout.write('\n__ARKTS_PRECHECK_JSON_END__\n');
+  process.exitCode = errorCount > 0 ? 1 : 0;
+}
+main();
+`;
+async function exists(pathname) {
+  try {
+    await access(pathname, fsConstants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args, cwd, timeoutSeconds) {
+  return await new Promise((resolve) => {
+    const proc = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = timeoutSeconds && timeoutSeconds > 0 ? setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGKILL");
+    }, timeoutSeconds * 1e3) : null;
+    proc.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve({ code: code ?? 1, stdout, stderr, timedOut });
+    });
+    proc.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      stderr += error instanceof Error ? error.message : String(error);
+      resolve({ code: 1, stdout, stderr, timedOut });
+    });
+  });
+}
+async function clearArtifacts(...paths) {
+  await Promise.all(paths.map(async (pathname) => {
+    await rm(pathname, { force: true });
+  }));
+}
+function candidateRoots(commandlineTools) {
+  const resolved = path.resolve(commandlineTools);
+  return [.../* @__PURE__ */ new Set([resolved, path.dirname(resolved)])];
+}
+async function findArktsTool(commandlineTools) {
+  if (!commandlineTools) return { etsLoader: null };
+  const candidates = [];
+  for (const root of candidateRoots(commandlineTools)) {
+    candidates.push(
+      path.join(root, "sdk", "default", "openharmony", "ets", "build-tools", "ets-loader"),
+      path.join(root, "sdk", "openharmony", "ets", "build-tools", "ets-loader"),
+      path.join(root, "default", "openharmony", "ets", "build-tools", "ets-loader"),
+      path.join(root, "openharmony", "ets", "build-tools", "ets-loader")
+    );
+  }
+  for (const candidate of candidates) {
+    if (await exists(path.join(candidate, "lib", "ets_checker.js")) && await exists(path.join(candidate, "main.js"))) {
+      return { etsLoader: candidate };
+    }
+  }
+  return { etsLoader: null };
+}
+async function findHmsSdkEts(commandlineTools) {
+  if (!commandlineTools) return null;
+  const candidates = [];
+  for (const root of candidateRoots(commandlineTools)) {
+    candidates.push(
+      path.join(root, "sdk", "default", "hms", "ets"),
+      path.join(root, "sdk", "hms", "ets"),
+      path.join(root, "default", "hms", "ets"),
+      path.join(root, "hms", "ets")
+    );
+  }
+  for (const candidate of candidates) {
+    if (await exists(candidate)) return candidate;
+  }
+  return null;
+}
+async function findSystemResourceFile(commandlineTools) {
+  if (!commandlineTools) return null;
+  const candidates = [];
+  for (const root of candidateRoots(commandlineTools)) {
+    candidates.push(
+      path.join(root, "sdk", "default", "openharmony", "previewer", "common", "resources", "entry", "resources.txt"),
+      path.join(root, "sdk", "openharmony", "previewer", "common", "resources", "entry", "resources.txt"),
+      path.join(root, "default", "openharmony", "previewer", "common", "resources", "entry", "resources.txt"),
+      path.join(root, "openharmony", "previewer", "common", "resources", "entry", "resources.txt")
+    );
+  }
+  for (const candidate of candidates) {
+    if (await exists(candidate)) return candidate;
+  }
+  return null;
+}
+async function collectEtsFiles(projectRoot) {
+  const srcDir = path.join(projectRoot, "entry", "src", "main", "ets");
+  if (!await exists(srcDir)) return [];
+  const ignored = /* @__PURE__ */ new Set(["node_modules", "oh_modules", "build", ".cache"]);
+  const files = [];
+  async function walk(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDir, entry.name);
+      if (absolutePath.split(path.sep).some((part) => ignored.has(part))) continue;
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!absolutePath.endsWith(".ets") || absolutePath.endsWith(".d.ets")) continue;
+      files.push(path.resolve(absolutePath));
+    }
+  }
+  await walk(srcDir);
+  files.sort();
+  return files;
+}
+function stripJson5Comments(text) {
+  return text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function extractJson5String(text, key) {
+  const match = new RegExp(`"${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"\\s*:\\s*"([^"]+)"`).exec(text);
+  return match?.[1] ?? null;
+}
+function parseApiLevel(value) {
+  if (!value) return null;
+  const paren = /\((\d+)\)/.exec(value);
+  if (paren) return Number.parseInt(paren[1], 10);
+  const plain = /\b(\d+)\b/.exec(value);
+  return plain ? Number.parseInt(plain[1], 10) : null;
+}
+async function readText(pathname) {
+  return await exists(pathname) ? await readFile(pathname, "utf8") : "";
+}
+async function projectCheckerConfig(projectRoot) {
+  const rootProfile = stripJson5Comments(await readText(path.join(projectRoot, "build-profile.json5")));
+  const entryProfile = stripJson5Comments(await readText(path.join(projectRoot, "entry", "build-profile.json5")));
+  const moduleJson = stripJson5Comments(await readText(path.join(projectRoot, "entry", "src", "main", "module.json5")));
+  const compatible = parseApiLevel(extractJson5String(rootProfile, "compatibleSdkVersion")) ?? 12;
+  const apiType = extractJson5String(entryProfile, "apiType") ?? "stageMode";
+  const permissions = [...new Set([...moduleJson.matchAll(/"name"\s*:\s*"(ohos\.permission\.[^"]+)"/g)].map((match) => match[1]))].sort();
+  return { compatibleSdkVersion: compatible, apiType, permissions };
+}
+function extractCheckerJson(stdout) {
+  const startMarker = "__ARKTS_PRECHECK_JSON_START__";
+  const endMarker = "__ARKTS_PRECHECK_JSON_END__";
+  const start = stdout.lastIndexOf(startMarker);
+  const end = stdout.lastIndexOf(endMarker);
+  if (start >= 0 && end > start) {
+    const snippet = stdout.slice(start + startMarker.length, end).trim();
+    try {
+      const parsed = JSON.parse(snippet);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  const first = stdout.indexOf("{");
+  const last = stdout.lastIndexOf("}");
+  if (first >= 0 && last > first) {
+    const snippet = stdout.slice(first, last + 1);
+    try {
+      const parsed = JSON.parse(snippet);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function filterProjectConfiguredDiagnostics(payload, checkerConfig) {
+  const permissions = new Set((Array.isArray(checkerConfig.permissions) ? checkerConfig.permissions : []).map(String));
+  const compatible = Number(checkerConfig.compatibleSdkVersion ?? 0);
+  const filtered = [];
+  const suppressed = [];
+  for (const rawItem of Array.isArray(payload.errors) ? payload.errors : []) {
+    const item = rawItem;
+    const message = String(item.message ?? "");
+    const permMatches = new Set([...message.matchAll(/ohos\.permission\.[A-Z0-9_]+/g)].map((match) => match[0]));
+    if (permMatches.size > 0 && [...permMatches].every((name) => permissions.has(name))) {
+      suppressed.push({ ...item, suppressed_reason: "permission already declared in module.json5" });
+      continue;
+    }
+    const sdkMatch = /SDK version (\d+).*current compatible SDK version is (\d+)/.exec(message);
+    if (sdkMatch && compatible >= Number.parseInt(sdkMatch[1], 10)) {
+      suppressed.push({ ...item, suppressed_reason: "compatibleSdkVersion from build-profile.json5 is high enough" });
+      continue;
+    }
+    if (message.includes("current Mode is FA") && checkerConfig.apiType === "stageMode") {
+      suppressed.push({ ...item, suppressed_reason: "apiType from entry/build-profile.json5 is stageMode" });
+      continue;
+    }
+    filtered.push(item);
+  }
+  payload.errors = filtered;
+  payload.suppressed_diagnostics = suppressed;
+  payload.summary = {
+    errorCount: filtered.filter((item) => item.severity === "error").length,
+    warnCount: filtered.filter((item) => item.severity === "warning").length
+  };
+  payload.success = payload.summary.errorCount === 0;
+  return payload;
+}
+function validateCheckerPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return "checker emitted a non-object JSON payload";
+  }
+  if (payload.errors !== void 0 && !Array.isArray(payload.errors)) {
+    return "checker emitted a malformed errors payload";
+  }
+  for (const item of Array.isArray(payload.errors) ? payload.errors : []) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return "checker emitted a malformed errors payload";
+    }
+  }
+  return null;
+}
+function unavailable(reason, elapsedMs = 0) {
+  return {
+    tool: "arkts_standalone_precheck",
+    tool_status: "unavailable",
+    evidence_status: "partial",
+    success: true,
+    mode: "full",
+    reason,
+    checked_files: [],
+    errors: [],
+    summary: { errorCount: 0, warnCount: 0 },
+    elapsed_ms: elapsedMs
+  };
+}
+async function runArktsStandalonePrecheck(options) {
+  const started = Date.now();
+  const node = process.execPath;
+  if (!node) return unavailable("node executable not found");
+  const projectRoot = path.resolve(options.projectRoot);
+  const commandlineTools = path.resolve(options.commandlineTools);
+  const tool = await findArktsTool(commandlineTools);
+  if (!tool.etsLoader) {
+    return unavailable(`ets-loader not found under commandline tools: ${commandlineTools}`, Date.now() - started);
+  }
+  const selectedFiles = options.files?.length ? options.files.map((file) => path.resolve(file)) : await collectEtsFiles(projectRoot);
+  const checkedFiles = selectedFiles.filter((file) => file.startsWith(projectRoot + path.sep) && file.endsWith(".ets")).map((file) => path.relative(projectRoot, file).replace(/\\/g, "/"));
+  const checkerConfig = await projectCheckerConfig(projectRoot);
+  const hmsSdkEts = await findHmsSdkEts(commandlineTools);
+  const systemResourceFile = await findSystemResourceFile(commandlineTools);
+  if (!checkedFiles.length) {
+    return {
+      tool: "arkts_standalone_precheck",
+      tool_status: "ok",
+      success: true,
+      mode: "full",
+      ets_loader: tool.etsLoader,
+      project_config: checkerConfig,
+      checked_files: [],
+      errors: [],
+      summary: { errorCount: 0, warnCount: 0 },
+      elapsed_ms: Date.now() - started
+    };
+  }
+  await mkdir(options.outputDir, { recursive: true });
+  const runnerPath = path.join(options.outputDir, "arkts-standalone-check-runner.js");
+  const resultPath = path.join(options.outputDir, "arkts-raw-diagnostics.json");
+  const stdoutPath = path.join(options.outputDir, "arkts-checker-stdout.txt");
+  const stderrPath = path.join(options.outputDir, "arkts-checker-stderr.txt");
+  await clearArtifacts(resultPath, stdoutPath, stderrPath);
+  await writeFile(runnerPath, CHECKER_SCRIPT, "utf8");
+  const cacheDir = path.join(options.outputDir, "arkts-check-cache");
+  await mkdir(cacheDir, { recursive: true });
+  const args = [
+    runnerPath,
+    "--project",
+    projectRoot,
+    "--ets-loader",
+    tool.etsLoader,
+    "--output",
+    resultPath,
+    "--api-type",
+    String(checkerConfig.apiType),
+    "--compatible-sdk-version",
+    String(checkerConfig.compatibleSdkVersion)
+  ];
+  for (const permission of Array.isArray(checkerConfig.permissions) ? checkerConfig.permissions.map(String) : []) {
+    args.push("--permission", permission);
+  }
+  if (hmsSdkEts) args.push("--hms-sdk-ets", hmsSdkEts);
+  if (systemResourceFile) args.push("--sys-resource-file", systemResourceFile);
+  args.push("--cache-dir", cacheDir, "--files", ...checkedFiles);
+  const result = await runCommand(node, args, projectRoot, options.timeoutSeconds ?? 120);
+  if (result.timedOut) {
+    return unavailable(`arkts standalone checker timed out after ${options.timeoutSeconds ?? 120}s`, Date.now() - started);
+  }
+  await writeFile(stdoutPath, result.stdout || "", "utf8");
+  await writeFile(stderrPath, result.stderr || "", "utf8");
+  let payload = null;
+  let evidenceStatus = "partial";
+  if (await exists(resultPath)) {
+    try {
+      const parsed = JSON.parse(await readFile(resultPath, "utf8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        payload = parsed;
+        evidenceStatus = "raw_structured";
+      }
+    } catch {
+      payload = null;
+    }
+  }
+  if (!payload) {
+    payload = extractCheckerJson(result.stdout || "");
+    if (payload) evidenceStatus = "derived_from_text";
+  }
+  if (!payload) {
+    return {
+      tool: "arkts_standalone_precheck",
+      tool_status: "internal_error",
+      evidence_status: "partial",
+      success: true,
+      mode: "full",
+      reason: "checker did not emit JSON",
+      stdout_tail: (result.stdout || "").slice(-4e3),
+      stderr_tail: (result.stderr || "").slice(-4e3),
+      checked_files: checkedFiles,
+      errors: [],
+      summary: { errorCount: 0, warnCount: 0 },
+      elapsed_ms: Date.now() - started
+    };
+  }
+  const payloadError = validateCheckerPayload(payload);
+  if (payloadError) {
+    return {
+      tool: "arkts_standalone_precheck",
+      tool_status: "internal_error",
+      evidence_status: "partial",
+      success: true,
+      mode: "full",
+      reason: payloadError,
+      checked_files: checkedFiles,
+      errors: [],
+      summary: { errorCount: 0, warnCount: 0 },
+      elapsed_ms: Date.now() - started,
+      artifact_paths: {
+        raw_json: resultPath,
+        stdout: stdoutPath,
+        stderr: stderrPath,
+        runner: runnerPath
+      }
+    };
+  }
+  payload.tool = "arkts_standalone_precheck";
+  payload.tool_status = payload.tool_status ?? "ok";
+  payload.success = payload.success ?? result.code === 0;
+  payload.evidence_status = evidenceStatus;
+  payload.mode = "full";
+  payload.ets_loader = tool.etsLoader;
+  payload.project_config = checkerConfig;
+  payload.checked_files = checkedFiles;
+  payload.elapsed_ms = Date.now() - started;
+  payload = filterProjectConfiguredDiagnostics(payload, checkerConfig);
+  payload.artifact_paths = {
+    raw_json: resultPath,
+    stdout: stdoutPath,
+    stderr: stderrPath,
+    runner: runnerPath
+  };
+  if (result.stderr) payload.stderr_tail = result.stderr.slice(-4e3);
+  return payload;
+}
+export {
+  extractCheckerJson,
+  findArktsTool,
+  findHmsSdkEts,
+  findSystemResourceFile,
+  runArktsStandalonePrecheck
+};