deveco-harness 0.1.0

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

@@ -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';
+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(['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: string, deviceId: string) {
+  const args = [
+    hdc,
+    ...targetArgs(deviceId),
+    'shell',
+    'hidumper',
+    '-s',
+    '1201',
+    '-a',
+    '-p Faultlogger LogSuffixWithMs',
+  ];
+
+  return runHdc(args);
+}
+
+async function readFaultloggerViaLs(hdc: string, deviceId: string) {
+  const remote = '/data/log/faultlog/faultlogger';
+  const args = [hdc, ...targetArgs(deviceId), 'shell', 'ls', '-1', remote];
+
+  return runHdc(args);
+}
+
+function formatCandidates(names: string[], limit: number) {
+  return names.slice(0, limit).join('|');
+}
+
+function printProbeFailed(bundleName: string, nextAction: string) {
+  printKv({
+    status: 'probe_failed',
+    bundle_name: bundleName,
+    latest_faultlog: '',
+    latest_timestamp: '',
+    matched_count: '0',
+    candidates: '',
+    next_action: nextAction,
+  });
+}
+
+function printProbeNotFound(bundleName: string) {
+  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: string, names: string[], limit: number) {
+  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.ts --faultlog-name "${latest}" if you want a cleaner crash anchor.`,
+  });
+}
+
+async function loadCandidateNames(hdc: string, deviceId: string, bundleName: string, maxAgeMinutes: number) {
+  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();

package/skills/arkts-runtime-fix/scripts/shared/hdc.mjs

@@ -0,0 +1,107 @@
+/*
+ * 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 path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+
+function binary(name) {
+  return process.platform === 'win32' ? `${name}.exe` : name;
+}
+
+function envPath() {
+  return String(process.env.DEVECO_HOME || '').trim();
+}
+
+async function isDir(file) {
+  if (!file) {
+    return false;
+  }
+  return fs.stat(file).then((info) => info.isDirectory()).catch(() => false);
+}
+
+function nodePath(home) {
+  return process.platform === 'win32'
+    ? path.join(home, 'tools', 'node', 'node.exe')
+    : path.join(home, 'tools', 'node', 'bin', 'node');
+}
+
+function hdcPath(home) {
+  return path.join(home, 'sdk', 'default', 'openharmony', 'toolchains', binary('hdc'));
+}
+
+async function exists(file) {
+  return fs.access(file).then(() => true).catch(() => false);
+}
+
+async function findDevEcoHome() {
+  const env = envPath();
+  if (env && (await isDir(env)) && (await exists(nodePath(env)))) {
+    return env;
+  }
+}
+
+export function targetArgs(deviceId) {
+  return deviceId ? ['-t', deviceId] : [];
+}
+
+export async function resolveHdcBinary() {
+  const home = await findDevEcoHome();
+  if (!home) {
+    return { hdc: '', home: '', error: 'DevEco Studio path not found. Set DEVECO_HOME and retry.' };
+  }
+
+  const hdc = hdcPath(home);
+  if (!(await exists(hdc))) {
+    return { hdc: '', home, error: `hdc not found: ${hdc}` };
+  }
+
+  return { hdc, home, error: '' };
+}
+
+export async function resolveHdcOrThrow() {
+  const resolved = await resolveHdcBinary();
+  if (resolved.error) {
+    throw new Error(resolved.error);
+  }
+
+  return resolved.hdc;
+}
+
+export async function runHdc(cmd) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd[0], cmd.slice(1), {
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.setEncoding('utf8');
+    proc.stderr.setEncoding('utf8');
+    proc.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    proc.on('error', (error) => {
+      resolve({ stdout, stderr: error.message || stderr, exitCode: 1 });
+    });
+    proc.on('close', (code) => {
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+  });
+}

package/skills/arkts-runtime-fix/scripts/shared/hdc.ts

@@ -0,0 +1,58 @@
+/*
+ * 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 { findDevEcoHome, hdcPath } from '../../../../../src/tool/lib/env';
+
+export function targetArgs(deviceId: string | undefined) {
+  return deviceId ? ['-t', deviceId] : [];
+}
+
+export async function resolveHdcBinary() {
+  const home = await findDevEcoHome();
+  if (!home) {
+    return { hdc: '', home: '', error: 'DevEco Studio path not found. Set DEVECO_HOME and retry.' };
+  }
+
+  const hdc = hdcPath(home);
+  if (!(await Bun.file(hdc).exists())) {
+    return { hdc: '', home, error: `hdc not found: ${hdc}` };
+  }
+
+  return { hdc, home, error: '' };
+}
+
+export async function resolveHdcOrThrow() {
+  const resolved = await resolveHdcBinary();
+  if (resolved.error) {
+    throw new Error(resolved.error);
+  }
+
+  return resolved.hdc;
+}
+
+export async function runHdc(cmd: string[]) {
+  const proc = Bun.spawn({
+    cmd,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    proc.stdout ? Bun.readableStreamToText(proc.stdout) : Promise.resolve(''),
+    proc.stderr ? Bun.readableStreamToText(proc.stderr) : Promise.resolve(''),
+    proc.exited,
+  ]);
+
+  return { stdout, stderr, exitCode };
+}

package/skills/arkts-runtime-fix/scripts/shared/jscrash-faultlogger.mjs

@@ -0,0 +1,143 @@
+/*
+ * 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.
+ */
+
+const JSCRASH_FILE_RE = /\bjscrash-[A-Za-z0-9._-]+\.log\b/g;
+const JSCRASH_NAME_RE = /^jscrash-(.+)-(\d{10,17})\.log$/i;
+
+export function extractJscrashFaultlogNames(text) {
+  const matches = text.match(JSCRASH_FILE_RE);
+  if (!matches?.length) {
+    return [];
+  }
+
+  return [...new Set(matches.map((item) => item.trim()))];
+}
+
+function parseTrailingTimestampMs(raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    return null;
+  }
+
+  if (raw.length <= 11) {
+    return n * 1000;
+  }
+
+  return n;
+}
+
+function extractBundlePartFromBody(body) {
+  const uidSep = body.lastIndexOf('-');
+  if (uidSep <= 0) {
+    return body;
+  }
+
+  const maybeUid = body.slice(uidSep + 1);
+  if (/^\d{5,}$/.test(maybeUid)) {
+    return body.slice(0, uidSep);
+  }
+
+  return body;
+}
+
+function parseJscrashFaultlogName(name) {
+  const match = JSCRASH_NAME_RE.exec(name);
+  if (!match?.[1] || !match[2]) {
+    return null;
+  }
+
+  return {
+    bundlePart: extractBundlePartFromBody(match[1]),
+    timestampMs: parseTrailingTimestampMs(match[2]),
+  };
+}
+
+export function parseFaultlogEntry(name) {
+  const parsed = parseJscrashFaultlogName(name);
+  return {
+    name,
+    timestampMs: parsed?.timestampMs ?? null,
+  };
+}
+
+function normalizeBundleToken(bundleName) {
+  return bundleName.trim().toLowerCase();
+}
+
+export function faultlogMatchesBundle(name, bundleName) {
+  const token = normalizeBundleToken(bundleName);
+  if (!token) {
+    return true;
+  }
+
+  const parsed = parseJscrashFaultlogName(name);
+  if (parsed?.bundlePart) {
+    return parsed.bundlePart.toLowerCase() === token;
+  }
+
+  return name.toLowerCase().startsWith(`jscrash-${token}-`);
+}
+
+export function filterFaultlogsByBundle(names, bundleName) {
+  if (!bundleName.trim()) {
+    return names;
+  }
+
+  const filtered = names.filter((name) => faultlogMatchesBundle(name, bundleName));
+  return filtered.length ? filtered : names;
+}
+
+export function sortFaultlogsByRecency(names) {
+  const withMeta = names.map((name) => {
+    const entry = parseFaultlogEntry(name);
+    return { name, timestampMs: entry.timestampMs };
+  });
+
+  withMeta.sort((a, b) => {
+    const ta = a.timestampMs;
+    const tb = b.timestampMs;
+    if (ta !== null && tb !== null && ta !== tb) {
+      return tb - ta;
+    }
+    if (ta !== null && tb === null) {
+      return -1;
+    }
+    if (ta === null && tb !== null) {
+      return 1;
+    }
+
+    return b.name.localeCompare(a.name);
+  });
+
+  return withMeta.map((item) => item.name);
+}
+
+export function selectWithinMaxAge(names, maxAgeMinutes, nowMs) {
+  if (!Number.isFinite(maxAgeMinutes) || maxAgeMinutes <= 0) {
+    return names;
+  }
+
+  const windowMs = maxAgeMinutes * 60 * 1000;
+  const filtered = names.filter((name) => {
+    const ts = parseFaultlogEntry(name).timestampMs;
+    if (ts === null) {
+      return true;
+    }
+
+    return nowMs - ts <= windowMs;
+  });
+
+  return filtered.length ? filtered : names;
+}

package/skills/arkts-runtime-fix/scripts/shared/jscrash-faultlogger.ts

@@ -0,0 +1,148 @@
+/*
+ * 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.
+ */
+
+export type JscrashFaultlogEntry = {
+  name: string;
+  timestampMs: number | null;
+};
+
+const JSCRASH_FILE_RE = /\bjscrash-[A-Za-z0-9._-]+\.log\b/g;
+const JSCRASH_NAME_RE = /^jscrash-(.+)-(\d{10,17})\.log$/i;
+
+export function extractJscrashFaultlogNames(text: string): string[] {
+  const matches = text.match(JSCRASH_FILE_RE);
+  if (!matches?.length) {
+    return [];
+  }
+
+  return [...new Set(matches.map((item) => item.trim()))];
+}
+
+function parseTrailingTimestampMs(raw: string): number | null {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    return null;
+  }
+
+  if (raw.length <= 11) {
+    return n * 1000;
+  }
+
+  return n;
+}
+
+function extractBundlePartFromBody(body: string) {
+  const uidSep = body.lastIndexOf('-');
+  if (uidSep <= 0) {
+    return body;
+  }
+
+  const maybeUid = body.slice(uidSep + 1);
+  if (/^\d{5,}$/.test(maybeUid)) {
+    return body.slice(0, uidSep);
+  }
+
+  return body;
+}
+
+function parseJscrashFaultlogName(name: string) {
+  const match = JSCRASH_NAME_RE.exec(name);
+  if (!match?.[1] || !match[2]) {
+    return null;
+  }
+
+  return {
+    bundlePart: extractBundlePartFromBody(match[1]),
+    timestampMs: parseTrailingTimestampMs(match[2]),
+  };
+}
+
+export function parseFaultlogEntry(name: string): JscrashFaultlogEntry {
+  const parsed = parseJscrashFaultlogName(name);
+  return {
+    name,
+    timestampMs: parsed?.timestampMs ?? null,
+  };
+}
+
+function normalizeBundleToken(bundleName: string) {
+  return bundleName.trim().toLowerCase();
+}
+
+export function faultlogMatchesBundle(name: string, bundleName: string) {
+  const token = normalizeBundleToken(bundleName);
+  if (!token) {
+    return true;
+  }
+
+  const parsed = parseJscrashFaultlogName(name);
+  if (parsed?.bundlePart) {
+    return parsed.bundlePart.toLowerCase() === token;
+  }
+
+  return name.toLowerCase().startsWith(`jscrash-${token}-`);
+}
+
+export function filterFaultlogsByBundle(names: string[], bundleName: string) {
+  if (!bundleName.trim()) {
+    return names;
+  }
+
+  const filtered = names.filter((name) => faultlogMatchesBundle(name, bundleName));
+  return filtered.length ? filtered : names;
+}
+
+export function sortFaultlogsByRecency(names: string[]) {
+  const withMeta = names.map((name) => {
+    const entry = parseFaultlogEntry(name);
+    return { name, timestampMs: entry.timestampMs };
+  });
+
+  withMeta.sort((a, b) => {
+    const ta = a.timestampMs;
+    const tb = b.timestampMs;
+    if (ta !== null && tb !== null && ta !== tb) {
+      return tb - ta;
+    }
+    if (ta !== null && tb === null) {
+      return -1;
+    }
+    if (ta === null && tb !== null) {
+      return 1;
+    }
+
+    return b.name.localeCompare(a.name);
+  });
+
+  return withMeta.map((item) => item.name);
+}
+
+export function selectWithinMaxAge(names: string[], maxAgeMinutes: number, nowMs: number) {
+  if (!Number.isFinite(maxAgeMinutes) || maxAgeMinutes <= 0) {
+    return names;
+  }
+
+  const windowMs = maxAgeMinutes * 60 * 1000;
+  const filtered = names.filter((name) => {
+    const ts = parseFaultlogEntry(name).timestampMs;
+    if (ts === null) {
+      return true;
+    }
+
+    return nowMs - ts <= windowMs;
+  });
+
+  return filtered.length ? filtered : names;
+}