fix: restore HarmonyOS app inventory parity

Author: thymikee

packages/platform-harmonyos/src/runtime.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'vitest';
+import { expect, test, vi } from 'vitest';
 import type { PlatformRuntimeHost } from '@agent-device/contracts/platform';
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import { createHarmonyPlatformRuntime } from './runtime.ts';
@@ -13,8 +13,10 @@ const device: DeviceInfo = {
 };
 
 test('classifies the HarmonyOS runtime denominator', async () => {
+  const listApps = vi.fn(async () => [{ id: 'com.example.application', name: 'application' }]);
   const host = {
     processTransports: { resolve: async () => ({ mode: 'local' as const }) },
+    appInventory: { harmonyos: { listApps } },
   } as unknown as PlatformRuntimeHost;
   const binding = await createHarmonyPlatformRuntime(host).bind({
     device,
@@ -38,5 +40,10 @@ test('classifies the HarmonyOS runtime denominator', async () => {
   expect(facts.operations.ensureReady).toEqual({ available: true });
   expect(facts.operations.bootTarget).toMatchObject({ available: false });
   expect(facts.operations.bootTargetHeadless).toMatchObject({ available: false });
+  expect(facts.operations.listApps).toEqual({ available: true });
   await expect(binding.operations.ensureReady?.({})).resolves.toMatchObject({ booted: true });
+  await expect(binding.operations.listApps?.({ device, filter: 'all' })).resolves.toEqual([
+    { id: 'com.example.application', name: 'application' },
+  ]);
+  expect(listApps).toHaveBeenCalledWith(device, 'all', expect.any(AbortSignal));
 });

packages/platform-harmonyos/src/runtime.ts

@@ -5,6 +5,7 @@ import type {
   PlatformRuntimeOwner,
 } from '@agent-device/contracts/platform';
 import { localRuntimeOwner } from '@agent-device/contracts/platform';
+import type { DeviceInfo } from '@agent-device/kernel/device';
 import { createHarmonyAppLogRuntime } from './logs/runtime.ts';
 import {
   createHarmonyScreenRecordingOperations,
@@ -34,7 +35,7 @@ export function createHarmonyPlatformRuntime(host: PlatformRuntimeHost): Platfor
         ensureReady: available,
         bootTarget: unavailable,
         bootTargetHeadless: unavailable,
-        listApps: unavailable,
+        listApps: available,
       },
     });
   };
@@ -61,6 +62,12 @@ export function createHarmonyPlatformRuntime(host: PlatformRuntimeHost): Platfor
               })
             : {}),
           ensureReady: async () => ({ ...request.device, booted: true }),
+          listApps: async (input: { device: DeviceInfo; filter: 'all' | 'user-installed' }) =>
+            await host.appInventory.harmonyos.listApps(
+              input.device,
+              input.filter,
+              request.scope.signal,
+            ),
         }),
         [Symbol.asyncDispose]: async () => await logs[Symbol.asyncDispose](),
       }) satisfies DeviceBinding<PlatformRuntimeOperations>;

src/daemon/handlers/__tests__/session-capabilities.test.ts

@@ -173,6 +173,51 @@ test('capabilities excludes network when the runtime fact is unavailable', async
   expect(response.data?.availableCommands).not.toContain(PUBLIC_COMMANDS.network);
 });
 
+test('capabilities includes apps for the available HarmonyOS runtime fact', async () => {
+  const sessionName = 'harmony-capabilities';
+  const sessionStore = makeSessionStore('agent-device-capabilities-harmony-');
+  const harmonyDevice = {
+    platform: 'harmonyos',
+    id: 'harmony-capabilities',
+    name: 'HarmonyOS device',
+    kind: 'device',
+    target: 'mobile',
+    booted: true,
+  } as const;
+  sessionStore.set(sessionName, makeSession(sessionName, { device: harmonyDevice }));
+  const runtime = createAdmissionRuntime({
+    appLogAvailable: true,
+    networkAvailable: false,
+    appsAvailable: true,
+    providerMode: 'local',
+  });
+
+  const response = await withTargetDeviceResolutionScope(
+    async (request) => (request.platform === 'harmonyos' ? [harmonyDevice] : []),
+    async () =>
+      await handleSessionCommands({
+        req: {
+          token: 't',
+          session: sessionName,
+          command: PUBLIC_COMMANDS.capabilities,
+          positionals: [],
+          flags: {},
+        },
+        sessionName,
+        logPath: path.join(os.tmpdir(), 'daemon.log'),
+        sessionStore,
+        bindDevice: runtime.bindDevice,
+        inspectFacts: runtime.inspectFacts,
+        invoke: async () => ({ ok: true, data: {} }),
+      }),
+  );
+
+  expect(response?.ok).toBe(true);
+  if (!response?.ok) return;
+  expect(response.data?.availableCommands).toContain(PUBLIC_COMMANDS.apps);
+  expect(runtime.inspectFacts).toHaveBeenCalledOnce();
+});
+
 const APPS_UNAVAILABLE_CAPABILITY_CASES = [
   { label: 'Linux', device: LINUX_DEVICE, providerMode: 'local' },
   { label: 'Web', device: WEB_DESKTOP_DEVICE, providerMode: 'local' },

src/daemon/handlers/__tests__/session-inventory-harmonyos.test.ts

@@ -23,6 +23,18 @@ const HARMONY_DEVICE = {
 };
 const available = { available: true } as const;
 const unavailable = { available: false, reason: 'unsupported-platform-leaf' } as const;
+const listAppsOperation: PlatformRuntimeOperations['listApps'] = vi.fn(async ({ filter }) =>
+  filter === 'all'
+    ? [
+        { id: 'com.example.application', name: 'application' },
+        { id: 'com.ohos.settings', name: 'settings' },
+      ]
+    : [{ id: 'com.example.application', name: 'application' }],
+);
+const ensureReady = vi.fn(async (device: typeof HARMONY_DEVICE) => ({
+  ...device,
+  booted: true,
+}));
 
 function runtimeFacts(): RuntimeFacts<PlatformRuntimeOperations> {
   return {
@@ -33,7 +45,7 @@ function runtimeFacts(): RuntimeFacts<PlatformRuntimeOperations> {
       appLogStart: available,
       appLogReattach: available,
       appLogCleanup: available,
-      listApps: unavailable,
+      listApps: { available: true },
       networkDump: unavailable,
       screenRecordingStart: unavailable,
       screenRecordingReattach: unavailable,
@@ -54,7 +66,7 @@ const bindDevice: BindDeviceRuntime = async (device, use) => {
       device,
       owner: localRuntimeOwner('harmonyos'),
       facts: runtimeFacts(),
-      operations: { ensureReady: async () => device },
+      operations: { ensureReady, listApps: listAppsOperation },
       [Symbol.asyncDispose]: async () => {},
     },
     use,
@@ -63,10 +75,12 @@ const bindDevice: BindDeviceRuntime = async (device, use) => {
 
 beforeEach(() => {
   vi.mocked(inspectFacts).mockClear();
+  vi.mocked(listAppsOperation).mockClear();
+  vi.mocked(ensureReady).mockClear();
   bindCount = 0;
 });
 
-async function listApps(): Promise<DaemonResponse | null> {
+async function listApps(appsFilter: 'all' | 'user-installed'): Promise<DaemonResponse | null> {
   const sessionName = 'harmony-apps';
   const sessionStore = makeSessionStore();
   sessionStore.set(sessionName, makeSession(sessionName, HARMONY_DEVICE));
@@ -75,7 +89,7 @@ async function listApps(): Promise<DaemonResponse | null> {
     session: sessionName,
     command: 'apps',
     positionals: [],
-    flags: { appsFilter: 'all' },
+    flags: { appsFilter },
   };
   return await handleSessionInventoryCommands({
     req,
@@ -86,11 +100,25 @@ async function listApps(): Promise<DaemonResponse | null> {
   });
 }
 
-test('HarmonyOS apps remains fail-closed when the legacy capability rejected the leaf', async () => {
-  await expect(listApps()).resolves.toMatchObject({
-    ok: false,
-    error: { code: 'UNSUPPORTED_OPERATION' },
+test.each([
+  {
+    appsFilter: 'user-installed' as const,
+    expected: ['application (com.example.application)'],
+  },
+  {
+    appsFilter: 'all' as const,
+    expected: ['application (com.example.application)', 'settings (com.ohos.settings)'],
+  },
+])('HarmonyOS apps preserves the $appsFilter response parity', async ({ appsFilter, expected }) => {
+  await expect(listApps(appsFilter)).resolves.toMatchObject({
+    ok: true,
+    data: { apps: expected },
   });
   expect(inspectFacts).toHaveBeenCalledOnce();
-  expect(bindCount).toBe(0);
+  expect(bindCount).toBe(1);
+  expect(ensureReady).toHaveBeenCalledOnce();
+  expect(listAppsOperation).toHaveBeenCalledWith({
+    device: expect.any(Object),
+    filter: appsFilter,
+  });
 });