Address reviewer feedback on HarmonyOS platform support (#679)

- Fix duplicate import in snapshot.ts
- Wire HarmonyOS recording into daemon recording path (start/stop)
- Reject HarmonyOS permission deny with explicit UNSUPPORTED_OPERATION
- Fix ui-input typo to uiInput in app-lifecycle.ts
- Add harmonyos to Node client normalizers (normalizeOpenDevice, buildClientDevicePlatformFields)
- Update remote config schema and CLI tests to include harmonyos platform

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: wangcz

src/client-normalizers.ts

@@ -142,7 +142,7 @@ function buildClientDevicePlatformFields(
   platform: AgentDeviceDevice['platform'],
   id: string,
   simulatorSetPath?: string | null,
-): Pick<AgentDeviceSessionDevice, 'ios' | 'android'> {
+): Pick<AgentDeviceSessionDevice, 'ios' | 'android' | 'harmonyos'> {
   return {
     ios:
       platform === 'ios'
@@ -152,6 +152,7 @@ function buildClientDevicePlatformFields(
           }
         : undefined,
     android: platform === 'android' ? { serial: id } : undefined,
+    harmonyos: platform === 'harmonyos' ? { serial: id } : undefined,
   };
 }
 
@@ -181,6 +182,7 @@ export function normalizeOpenDevice(
     (platform !== 'ios' &&
       platform !== 'macos' &&
       platform !== 'android' &&
+      platform !== 'harmonyos' &&
       platform !== 'linux') ||
     !id ||
     !name
@@ -204,6 +206,10 @@ export function normalizeOpenDevice(
         : undefined,
     android:
       platform === 'android' ? { serial: readOptionalString(value, 'serial') ?? id } : undefined,
+    harmonyos:
+      platform === 'harmonyos'
+        ? { serial: readOptionalString(value, 'serial') ?? id }
+        : undefined,
   };
 }
 

src/client-types.ts

@@ -114,6 +114,9 @@ export type AgentDeviceDevice = {
   android?: {
     serial: string;
   };
+  harmonyos?: {
+    serial: string;
+  };
 };
 
 export type AgentDeviceSessionDevice = {
@@ -129,6 +132,9 @@ export type AgentDeviceSessionDevice = {
   android?: {
     serial: string;
   };
+  harmonyos?: {
+    serial: string;
+  };
 };
 
 export type AgentDeviceSession = {

src/daemon/handlers/record-trace-recording.ts

@@ -41,6 +41,10 @@ import {
   stopIosSimulatorRecordingProcess,
 } from './record-trace-ios-simulator.ts';
 import { resolveImplicitSessionScope, resolvePublicSessionName } from '../session-routing.ts';
+import {
+  startHarmonyRecording,
+  stopHarmonyRecording,
+} from '../../platforms/harmonyos/recording.ts';
 
 const IOS_DEVICE_RECORD_MIN_FPS = 1;
 const IOS_DEVICE_RECORD_MAX_FPS = 120;
@@ -175,6 +179,35 @@ async function startIosSimulatorRecording(params: {
   };
 }
 
+// --- HarmonyOS start helper ---
+
+async function startHarmonyOsRecording(params: {
+  device: SessionState['device'];
+  recordingBase: RecordingBase;
+}): Promise<DaemonResponse | NonNullable<SessionState['recording']>> {
+  const { device, recordingBase } = params;
+  const remotePath = `/data/local/tmp/agent-device-recording-${Date.now()}.mp4`;
+
+  let startResult: { remotePid: string };
+  try {
+    startResult = await startHarmonyRecording(device, remotePath);
+  } catch (error) {
+    return errorResponse(
+      'COMMAND_FAILED',
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+
+  const recording: Extract<NonNullable<SessionState['recording']>, { platform: 'harmonyos' }> = {
+    platform: 'harmonyos',
+    remotePath,
+    remotePid: startResult.remotePid,
+    ...recordingBase,
+    startedAt: Date.now(),
+  };
+  return recording;
+}
+
 // --- Start recording orchestrator ---
 
 // fallow-ignore-next-line complexity
@@ -276,6 +309,8 @@ async function startRecording(params: {
       recordingBase,
       resolvedOut,
     });
+  } else if (device.platform === 'harmonyos') {
+    recording = await startHarmonyOsRecording({ device, recordingBase });
   } else {
     recording = await startAndroidRecording({ device, recordingBase });
   }
@@ -427,6 +462,28 @@ function removeInvalidRecordingOutput(outPath: string): void {
   }
 }
 
+async function stopHarmonyOsRecording(params: {
+  device: SessionState['device'];
+  recording: Extract<NonNullable<SessionState['recording']>, { platform: 'harmonyos' }>;
+  stopRequestedAt: number;
+}): Promise<DaemonResponse | null> {
+  const { device, recording, stopRequestedAt } = params;
+  try {
+    await stopHarmonyRecording({
+      device,
+      remotePid: recording.remotePid,
+      remotePath: recording.remotePath,
+      localPath: recording.outPath,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const failure = buildRecordStopFailure(message, recording, stopRequestedAt);
+    removeInvalidRecordingOutput(recording.outPath);
+    return errorResponse('COMMAND_FAILED', failure.message);
+  }
+  return null;
+}
+
 async function stopRecording(params: {
   req: DaemonRequest;
   activeSession: SessionState;
@@ -450,7 +507,9 @@ async function stopRecording(params: {
       ? await stopIosDeviceRecording({ req, activeSession, device, logPath, deps, recording })
       : recording.platform === 'macos-runner'
         ? await stopMacOsRecording({ req, activeSession, device, logPath, deps, recording })
-        : await stopNonRunnerRecording({ deps, device, recording, stopRequestedAt });
+        : recording.platform === 'harmonyos'
+          ? await stopHarmonyOsRecording({ device, recording, stopRequestedAt })
+          : await stopNonRunnerRecording({ deps, device, recording, stopRequestedAt });
   if (stopError) {
     return stopError;
   }

src/daemon/types.ts

@@ -250,6 +250,11 @@ export type SessionState = {
     | (SessionRecordingBase & {
         platform: 'macos-runner';
         remotePath?: string;
+      })
+    | (SessionRecordingBase & {
+        platform: 'harmonyos';
+        remotePath: string;
+        remotePid: string;
       });
   /** Session-scoped app log stream; logs written to outPath for agent to grep */
   appLog?: {

src/platforms/harmonyos/app-lifecycle.ts

@@ -182,7 +182,7 @@ async function checkAndHandleScreenLock(device: DeviceInfo): Promise<void> {
         // Try to unlock (swipe up)
         await runHarmonyHdc(
           device,
-          ['shell', 'uitest', 'ui-input', 'swipe', '540', '2000', '540', '800', '300'],
+          ['shell', 'uitest', 'uiInput', 'swipe', '540', '2000', '540', '800', '300'],
           { allowFailure: true },
         );
         // Wait for screen to wake

src/platforms/harmonyos/recording.ts

@@ -2,24 +2,46 @@ import type { DeviceInfo } from '../../utils/device.ts';
 import { AppError } from '../../utils/errors.ts';
 import { runHarmonyHdc } from './hdc.ts';
 
-export async function startHarmonyRecording(device: DeviceInfo, remotePath: string): Promise<void> {
-  // HarmonyOS screen recording via hdc shell screenrecord
-  // This command may not be available on all devices
-  await runHarmonyHdc(device, ['shell', 'screenrecord', '--output', remotePath], {
-    allowFailure: true,
-    timeoutMs: 5_000,
-  });
-}
+const HARMONY_PROCESS_EXIT_POLL_MS = 250;
+const HARMONY_PROCESS_EXIT_ATTEMPTS = 40;
 
-export async function stopHarmonyRecording(
+export async function startHarmonyRecording(
   device: DeviceInfo,
   remotePath: string,
-  localPath: string,
-): Promise<void> {
-  // Stop recording (kill the screenrecord process)
-  await runHarmonyHdc(device, ['shell', 'aa', 'force-stop', 'com.ohos.screenrecorder'], {
-    allowFailure: true,
-  });
+): Promise<{ remotePid: string }> {
+  const shellCmd = `screenrecord --output ${remotePath} >/dev/null 2>&1 & echo $!`;
+  const result = await runHarmonyHdc(device, ['shell', shellCmd], { allowFailure: true });
+
+  if (result.exitCode !== 0) {
+    throw new AppError('COMMAND_FAILED', `Failed to start HarmonyOS recording: ${result.stderr}`);
+  }
+
+  const remotePid = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => /^\d+$/.test(line))
+    .at(-1);
+
+  if (!remotePid) {
+    throw new AppError('COMMAND_FAILED', 'Failed to get HarmonyOS screenrecord PID');
+  }
+
+  return { remotePid };
+}
+
+export async function stopHarmonyRecording(params: {
+  device: DeviceInfo;
+  remotePid: string;
+  remotePath: string;
+  localPath: string;
+}): Promise<void> {
+  const { device, remotePid, remotePath, localPath } = params;
+
+  // Send SIGINT to gracefully stop screenrecord
+  await runHarmonyHdc(device, ['shell', 'kill', '-2', remotePid], { allowFailure: true });
+
+  // Wait for process to exit
+  await waitForHarmonyProcessExit(device, remotePid);
 
   // Pull the recording file
   try {
@@ -28,9 +50,31 @@ export async function stopHarmonyRecording(
       timeoutMs: 30_000,
     });
   } catch {
-    throw new AppError('COMMAND_FAILED', 'Failed to retrieve recording file');
+    throw new AppError('COMMAND_FAILED', 'Failed to retrieve HarmonyOS recording file');
   }
 
   // Cleanup remote
   await runHarmonyHdc(device, ['shell', 'rm', '-f', remotePath], { allowFailure: true });
 }
+
+async function isHarmonyProcessRunning(device: DeviceInfo, pid: string): Promise<boolean> {
+  const result = await runHarmonyHdc(device, ['shell', 'ps', '-o', 'pid=', '-p', pid], {
+    allowFailure: true,
+  });
+  if (result.exitCode !== 0) {
+    return false;
+  }
+  return result.stdout
+    .split(/\s+/)
+    .map((value) => value.trim())
+    .includes(pid);
+}
+
+async function waitForHarmonyProcessExit(device: DeviceInfo, pid: string): Promise<void> {
+  for (let attempt = 0; attempt < HARMONY_PROCESS_EXIT_ATTEMPTS; attempt += 1) {
+    if (!(await isHarmonyProcessRunning(device, pid))) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, HARMONY_PROCESS_EXIT_POLL_MS));
+  }
+}

src/platforms/harmonyos/settings.ts

@@ -178,14 +178,20 @@ async function setHarmonyPermission(
 ): Promise<void> {
   // HarmonyOS permission management uses different commands than Android
   // This is a simplified implementation - actual HarmonyOS may need specific APIs
+  if (action === 'deny') {
+    throw new AppError(
+      'UNSUPPORTED_OPERATION',
+      'HarmonyOS permission deny is not yet implemented',
+    );
+  }
   if (action === 'reset') {
     throw new AppError(
       'UNSUPPORTED_OPERATION',
       'HarmonyOS permission reset is not yet implemented',
     );
   }
 
-  // Try using bm tool for permission management (if available)
+  // Only grant is supported for now
   const result = await runHarmonyHdc(
     device,
     ['shell', 'bm', 'grant-permission', '-n', appPackage, '-p', permission],

src/platforms/harmonyos/snapshot.ts

@@ -4,8 +4,7 @@ import path from 'node:path';
 import os from 'node:os';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { AppError } from '../../utils/errors.ts';
-import type { SnapshotOptions } from '../../utils/snapshot.ts';
-import { attachRefs, type SnapshotNode } from '../../utils/snapshot.ts';
+import { attachRefs, type SnapshotNode, type SnapshotOptions } from '../../utils/snapshot.ts';
 import { runHarmonyHdc } from './hdc.ts';
 import {
   parseArkUiTree,

src/remote-config-schema.ts

@@ -73,7 +73,7 @@ export const REMOTE_CONFIG_FIELD_SPECS = [
     type: 'enum',
     enumValues: ['ios-simulator', 'ios-instance', 'android-instance'],
   },
-  { key: 'platform', type: 'enum', enumValues: ['ios', 'macos', 'android', 'linux', 'apple'] },
+  { key: 'platform', type: 'enum', enumValues: ['ios', 'macos', 'android', 'harmonyos', 'linux', 'apple'] },
   { key: 'target', type: 'enum', enumValues: ['mobile', 'tv', 'desktop'] },
   { key: 'device', type: 'string' },
   { key: 'udid', type: 'string' },

src/utils/__tests__/args.test.ts

@@ -1518,7 +1518,7 @@ test('command usage shows command and global flags separately', () => {
   assert.match(help, /Command flags:/);
   assert.match(help, /--pattern one-way\|ping-pong/);
   assert.match(help, /Global flags:/);
-  assert.match(help, /--platform ios\|macos\|android\|linux\|apple/);
+  assert.match(help, /--platform ios\|macos\|android\|harmonyos\|linux\|apple/);
 });
 
 test('back command usage documents explicit mode flags', () => {