deveco-harness 0.1.0

package/skills/arkts-runtime-fix/scripts/fetch-faultlog.ts

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { resolveHdcOrThrow, runHdc, targetArgs } from './shared/hdc';
+import { printKv, toErrorMessage } from './shared/utils';
+
+function parseArgs(argv: string[]) {
+  const map = new Map<string, string>();
+  const optionalKeys = new Set(['device-id']);
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    if (!t.startsWith('--')) {
+      continue;
+    }
+    const key = t.slice(2);
+    const val = argv[i + 1];
+    if (!val || val.startsWith('--')) {
+      if (optionalKeys.has(key)) {
+        map.set(key, '');
+        continue;
+      }
+
+      throw new Error(`Missing value for --${key}`);
+    }
+    map.set(key, val);
+    i += 1;
+  }
+
+  const faultlogName = map.get('faultlog-name');
+  const outputDir = map.get('output-dir');
+  if (!faultlogName || !outputDir) {
+    throw new Error('Required: --faultlog-name and --output-dir');
+  }
+
+  return {
+    faultlogName,
+    outputDir,
+    deviceId: map.get('device-id') ?? '',
+  };
+}
+
+function normalizeRemoteName(name: string) {
+  return name.endsWith('.log') ? name : `${name}.log`;
+}
+
+function printFetchFailed(faultlogName: string, remotePath: string, nextAction: string) {
+  printKv({
+    status: 'fetch_failed',
+    faultlog_name: faultlogName,
+    remote_path: remotePath,
+    local_path: '',
+    next_action: nextAction,
+  });
+}
+
+async function recvFaultlog(hdc: string, deviceId: string, remotePath: string, localPath: string) {
+  const args = [hdc, ...targetArgs(deviceId), 'file', 'recv', remotePath, localPath];
+  const out = await runHdc(args);
+  if (out.exitCode !== 0) {
+    throw new Error(out.stderr || out.stdout || `hdc file recv failed (code=${out.exitCode})`);
+  }
+
+  if (!(await Bun.file(localPath).exists())) {
+    throw new Error('Local file missing after recv.');
+  }
+}
+
+function printFetched(faultlogName: string, remotePath: string, localPath: string) {
+  printKv({
+    status: 'fetched',
+    faultlog_name: faultlogName,
+    remote_path: remotePath,
+    local_path: localPath,
+    next_action: `parse-jscrash-log.ts --log-file "${localPath}"`,
+  });
+}
+
+async function main() {
+  let faultlogName = '';
+  let remotePath = '';
+
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const base = normalizeRemoteName(path.basename(args.faultlogName.trim()));
+    faultlogName = base;
+    remotePath = `/data/log/faultlog/faultlogger/${base}`;
+    const hdc = await resolveHdcOrThrow();
+
+    fs.mkdirSync(args.outputDir, { recursive: true });
+    const localPath = path.join(args.outputDir, base);
+    await recvFaultlog(hdc, args.deviceId, remotePath, localPath);
+    printFetched(base, remotePath, localPath);
+    process.exit(0);
+  } catch (err) {
+    printFetchFailed(faultlogName, remotePath, toErrorMessage(err));
+    process.exit(1);
+  }
+}
+
+await main();

package/skills/arkts-runtime-fix/scripts/jscrash-report.mjs

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from 'node:fs/promises';
+import process from 'node:process';
+import {
+  buildCrashReport,
+  buildNextActionText,
+  formatCrashReportText,
+} from './shared/jscrash-parse.mjs';
+import { resolveHdcOrThrow, runHdc, targetArgs } from './shared/hdc.mjs';
+import { printKv, toErrorMessage } from './shared/utils.mjs';
+
+function parseArgs(argv) {
+  const map = new Map();
+  const flags = new Set();
+  const optionalKeys = new Set(['log-text', 'log-file', 'bundle-name', 'process-hint', 'device-id']);
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--include-text') {
+      flags.add('include-text');
+      continue;
+    }
+    if (!token.startsWith('--')) {
+      continue;
+    }
+    const key = token.slice(2);
+    const value = argv[i + 1];
+    if (!value || value.startsWith('--')) {
+      if (optionalKeys.has(key)) {
+        map.set(key, '');
+        continue;
+      }
+      throw new Error(`Missing value for --${key}`);
+    }
+    map.set(key, value);
+    i += 1;
+  }
+
+  const logText = map.get('log-text');
+  const logFile = map.get('log-file');
+  if (logText && logFile) {
+    throw new Error('Provide at most one of --log-text or --log-file');
+  }
+
+  const lines = Number(map.get('lines') ?? '4000');
+  if (!Number.isInteger(lines) || lines < 200 || lines > 10000) {
+    throw new Error('--lines must be an integer between 200 and 10000');
+  }
+
+  return {
+    logText,
+    logFile,
+    bundleName: map.get('bundle-name') ?? '',
+    processHint: map.get('process-hint') ?? '',
+    deviceId: map.get('device-id') ?? '',
+    lines,
+    includeText: flags.has('include-text'),
+  };
+}
+
+function cleanLines(input) {
+  return input
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim().length > 0);
+}
+
+async function collectHilogText(deviceId, lines) {
+  const hdc = await resolveHdcOrThrow();
+  const out = await runHdc([hdc, ...targetArgs(deviceId), 'shell', 'hilog', '-x']);
+  if (out.exitCode !== 0) {
+    throw new Error(out.stderr || out.stdout || `hdc hilog -x failed (code=${out.exitCode})`);
+  }
+
+  const all = cleanLines(out.stdout);
+  return all.slice(Math.max(0, all.length - lines)).join('\n');
+}
+
+async function loadInput(args) {
+  if (args.logText) {
+    return { text: args.logText, source: 'text' };
+  }
+  if (args.logFile) {
+    return { text: await fs.readFile(args.logFile, 'utf8'), source: 'file' };
+  }
+  return { text: await collectHilogText(args.deviceId, args.lines), source: 'device_hilog' };
+}
+
+function printReport(report, source, includeText) {
+  printKv({
+    status: report.status === 'detected' ? 'detected' : 'no_crash_signature',
+    source,
+    error_type: report.errorType,
+    error_message: report.errorMessage,
+    suspected_file: report.suspectedFile,
+    top_stack: report.topStack.join('|'),
+    keywords: report.keywords.join(','),
+    next_action: buildNextActionText(report),
+  });
+
+  if (includeText) {
+    console.log('');
+    console.log(formatCrashReportText(report));
+  }
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const input = await loadInput(args);
+    const report = buildCrashReport(
+      input.text,
+      input.source,
+      args.deviceId || 'default',
+      args.bundleName,
+      args.processHint,
+    );
+    printReport(report, input.source, args.includeText);
+    process.exit(0);
+  } catch (err) {
+    printKv({
+      status: 'parse_failed',
+      source: 'text',
+      error_type: '',
+      error_message: '',
+      suspected_file: '',
+      top_stack: '',
+      keywords: '',
+      next_action: toErrorMessage(err),
+    });
+    process.exit(1);
+  }
+}
+
+await main();

package/skills/arkts-runtime-fix/scripts/parse-jscrash-log.mjs

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import {
+  buildCrashReport,
+  buildNextActionText,
+  formatCrashReportText,
+} from './shared/jscrash-parse.mjs';
+import { printKv, toErrorMessage } from './shared/utils.mjs';
+
+function parseArgs(argv) {
+  const map = new Map();
+  const flags = new Set();
+  const optionalKeys = new Set(['bundle-name', 'process-hint', 'device', 'source']);
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    if (t === '--include-text') {
+      flags.add('include-text');
+      continue;
+    }
+    if (!t.startsWith('--')) {
+      continue;
+    }
+    const key = t.slice(2);
+    const val = argv[i + 1];
+    if (!val || val.startsWith('--')) {
+      if (optionalKeys.has(key)) {
+        map.set(key, '');
+        continue;
+      }
+
+      throw new Error(`Missing value for --${key}`);
+    }
+    map.set(key, val);
+    i += 1;
+  }
+
+  const logFile = map.get('log-file');
+  const logText = map.get('log-text');
+  if ((logFile && logText) || (!logFile && !logText)) {
+    throw new Error('Provide exactly one of --log-file or --log-text');
+  }
+
+  return {
+    logFile,
+    logText,
+    bundleName: map.get('bundle-name') ?? '',
+    processHint: map.get('process-hint') ?? '',
+    source: map.get('source') ?? (logFile ? 'file' : 'text'),
+    device: map.get('device') ?? 'default',
+    includeText: flags.has('include-text'),
+  };
+}
+
+async function readLogText(logFile) {
+  try {
+    return await fs.readFile(logFile, 'utf8');
+  } catch {
+    throw new Error(`log file not found: ${logFile}`);
+  }
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    let raw = '';
+    if (args.logFile) {
+      raw = await readLogText(args.logFile);
+    } else if (args.logText) {
+      raw = args.logText;
+    }
+
+    const report = buildCrashReport(raw, args.source, args.device, args.bundleName, args.processHint);
+    const nextAction = buildNextActionText(report);
+
+    const topStackJoined = report.topStack.join('|');
+    const keywordsJoined = report.keywords.join(',');
+
+    printKv({
+      status: report.status === 'detected' ? 'detected' : 'no_crash_signature',
+      source: args.source,
+      error_type: report.errorType,
+      error_message: report.errorMessage,
+      suspected_file: report.suspectedFile,
+      top_stack: topStackJoined,
+      keywords: keywordsJoined,
+      next_action: nextAction,
+    });
+
+    if (args.includeText) {
+      console.log('');
+      console.log(formatCrashReportText(report));
+    }
+
+    process.exit(0);
+  } catch (err) {
+    printKv({
+      status: 'parse_failed',
+      source: 'text',
+      error_type: '',
+      error_message: '',
+      suspected_file: '',
+      top_stack: '',
+      keywords: '',
+      next_action: toErrorMessage(err),
+    });
+    process.exit(1);
+  }
+}
+
+await main();

package/skills/arkts-runtime-fix/scripts/parse-jscrash-log.ts

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import process from 'node:process';
+import {
+  buildCrashReport,
+  buildNextActionText,
+  formatCrashReportText,
+} from './shared/jscrash-parse';
+import { printKv, toErrorMessage } from './shared/utils';
+
+function parseArgs(argv: string[]) {
+  const map = new Map<string, string>();
+  const flags = new Set<string>();
+  const optionalKeys = new Set(['bundle-name', 'process-hint', 'device', 'source']);
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    if (t === '--include-text') {
+      flags.add('include-text');
+      continue;
+    }
+    if (!t.startsWith('--')) {
+      continue;
+    }
+    const key = t.slice(2);
+    const val = argv[i + 1];
+    if (!val || val.startsWith('--')) {
+      if (optionalKeys.has(key)) {
+        map.set(key, '');
+        continue;
+      }
+
+      throw new Error(`Missing value for --${key}`);
+    }
+    map.set(key, val);
+    i += 1;
+  }
+
+  const logFile = map.get('log-file');
+  const logText = map.get('log-text');
+  if ((logFile && logText) || (!logFile && !logText)) {
+    throw new Error('Provide exactly one of --log-file or --log-text');
+  }
+
+  return {
+    logFile,
+    logText,
+    bundleName: map.get('bundle-name') ?? '',
+    processHint: map.get('process-hint') ?? '',
+    source: map.get('source') ?? (logFile ? 'file' : 'text'),
+    device: map.get('device') ?? 'default',
+    includeText: flags.has('include-text'),
+  };
+}
+
+async function readLogText(logFile: string) {
+  const file = Bun.file(logFile);
+  if (!(await file.exists())) {
+    throw new Error(`log file not found: ${logFile}`);
+  }
+
+  return file.text();
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    let raw = '';
+    if (args.logFile) {
+      raw = await readLogText(args.logFile);
+    } else if (args.logText) {
+      raw = args.logText;
+    }
+
+    const report = buildCrashReport(raw, args.source, args.device, args.bundleName, args.processHint);
+    const nextAction = buildNextActionText(report);
+
+    const topStackJoined = report.topStack.join('|');
+    const keywordsJoined = report.keywords.join(',');
+
+    printKv({
+      status: report.status === 'detected' ? 'detected' : 'no_crash_signature',
+      source: args.source,
+      error_type: report.errorType,
+      error_message: report.errorMessage,
+      suspected_file: report.suspectedFile,
+      top_stack: topStackJoined,
+      keywords: keywordsJoined,
+      next_action: nextAction,
+    });
+
+    if (args.includeText) {
+      console.log('');
+      console.log(formatCrashReportText(report));
+    }
+
+    process.exit(0);
+  } catch (err) {
+    printKv({
+      status: 'parse_failed',
+      source: 'text',
+      error_type: '',
+      error_message: '',
+      suspected_file: '',
+      top_stack: '',
+      keywords: '',
+      next_action: toErrorMessage(err),
+    });
+    process.exit(1);
+  }
+}
+
+await main();

package/skills/arkts-runtime-fix/scripts/probe-faultlogger.mjs

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import process from 'node:process';
+import {
+  extractJscrashFaultlogNames,
+  filterFaultlogsByBundle,
+  parseFaultlogEntry,
+  selectWithinMaxAge,
+  sortFaultlogsByRecency,
+} from './shared/jscrash-faultlogger.mjs';
+import { resolveHdcOrThrow, runHdc, targetArgs } from './shared/hdc.mjs';
+import { printKv, toErrorMessage } from './shared/utils.mjs';
+
+function parseArgs(argv) {
+  const map = new Map();
+  const optionalKeys = new Set(['bundle-name', 'device-id']);
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    if (!t.startsWith('--')) {
+      continue;
+    }
+    const key = t.slice(2);
+    const val = argv[i + 1];
+    if (!val || val.startsWith('--')) {
+      if (optionalKeys.has(key)) {
+        map.set(key, '');
+        continue;
+      }
+
+      throw new Error(`Missing value for --${key}`);
+    }
+    map.set(key, val);
+    i += 1;
+  }
+
+  return {
+    bundleName: map.get('bundle-name') ?? '',
+    deviceId: map.get('device-id') ?? '',
+    maxAgeMinutes: Number(map.get('max-age-minutes') ?? '30'),
+    limit: Number(map.get('limit') ?? '10'),
+  };
+}
+
+async function readFaultloggerViaHidumper(hdc, deviceId) {
+  const args = [
+    hdc,
+    ...targetArgs(deviceId),
+    'shell',
+    'hidumper',
+    '-s',
+    '1201',
+    '-a',
+    '-p Faultlogger LogSuffixWithMs',
+  ];
+
+  return runHdc(args);
+}
+
+async function readFaultloggerViaLs(hdc, deviceId) {
+  const remote = '/data/log/faultlog/faultlogger';
+  const args = [hdc, ...targetArgs(deviceId), 'shell', 'ls', '-1', remote];
+
+  return runHdc(args);
+}
+
+function formatCandidates(names, limit) {
+  return names.slice(0, limit).join('|');
+}
+
+function printProbeFailed(bundleName, nextAction) {
+  printKv({
+    status: 'probe_failed',
+    bundle_name: bundleName,
+    latest_faultlog: '',
+    latest_timestamp: '',
+    matched_count: '0',
+    candidates: '',
+    next_action: nextAction,
+  });
+}
+
+function printProbeNotFound(bundleName) {
+  printKv({
+    status: 'not_found',
+    bundle_name: bundleName,
+    latest_faultlog: '',
+    latest_timestamp: '',
+    matched_count: '0',
+    candidates: '',
+    next_action: 'No recent matching faultlog was found. You may collect hilog if you still need more runtime evidence, or reproduce and retry.',
+  });
+}
+
+function printProbeFound(bundleName, names, limit) {
+  const latest = names[0];
+  const ts = parseFaultlogEntry(latest).timestampMs;
+  printKv({
+    status: 'found',
+    bundle_name: bundleName,
+    latest_faultlog: latest,
+    latest_timestamp: ts === null ? '' : String(ts),
+    matched_count: String(names.length),
+    candidates: formatCandidates(names, limit),
+    next_action: `A recent faultlog is available. Fetch it with fetch-faultlog.mjs --faultlog-name "${latest}" if you want a cleaner crash anchor.`,
+  });
+}
+
+async function loadCandidateNames(hdc, deviceId, bundleName, maxAgeMinutes) {
+  const hidumper = await readFaultloggerViaHidumper(hdc, deviceId);
+  let combined = hidumper.exitCode === 0 ? hidumper.stdout : '';
+
+  const ls = await readFaultloggerViaLs(hdc, deviceId);
+  if (ls.exitCode === 0) {
+    combined = `${combined}\n${ls.stdout}`;
+  }
+
+  let names = extractJscrashFaultlogNames(combined);
+  names = filterFaultlogsByBundle(names, bundleName);
+  names = selectWithinMaxAge(names, maxAgeMinutes, Date.now());
+  return sortFaultlogsByRecency(names);
+}
+
+async function main() {
+  let bundleName = '';
+
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    bundleName = args.bundleName;
+    const hdc = await resolveHdcOrThrow();
+    const names = await loadCandidateNames(hdc, args.deviceId, args.bundleName, args.maxAgeMinutes);
+
+    if (!names.length) {
+      printProbeNotFound(args.bundleName);
+      process.exit(0);
+      return;
+    }
+
+    printProbeFound(args.bundleName, names, args.limit);
+    process.exit(0);
+  } catch (err) {
+    printProbeFailed(bundleName, toErrorMessage(err));
+    process.exit(1);
+  }
+}
+
+await main();