refactor: collapse semantic cli wrappers

Author: thymikee

src/cli/commands/apps.ts

@@ -1,9 +1,36 @@
-import type { AgentDeviceClient, CommandRequestResult } from '../../client.ts';
+import {
+  serializeCloseResult,
+  serializeDeployResult,
+  serializeDevice,
+  serializeInstallFromSourceResult,
+  serializeOpenResult,
+  serializeSessionListEntry,
+  serializeSnapshotResult,
+} from '../../client-shared.ts';
+import type {
+  AgentDeviceClient,
+  AgentDeviceDevice,
+  AgentDeviceSession,
+  AppCloseResult,
+  AppDeployResult,
+  AppInstallFromSourceResult,
+  AppOpenResult,
+  CaptureSnapshotResult,
+  CommandRequestResult,
+  SessionCloseResult,
+} from '../../client.ts';
 import { announceReplayTestRun } from '../../cli-test.ts';
 import { runSemanticCliCommand } from '../../commands/semantic-cli.ts';
-import { listSemanticGenericCliCommands } from '../../commands/semantic-command-surface.ts';
+import {
+  listSemanticGenericCliCommands,
+  type SemanticCliCommand,
+} from '../../commands/semantic-command-surface.ts';
+import { assertResolvedAppsFilter } from '../../commands/app-inventory-contract.ts';
 import type { CliFlags } from '../../utils/command-schema.ts';
+import { AppError } from '../../utils/errors.ts';
+import { formatSnapshotText } from '../../utils/output.ts';
 import { writeCommandCliOutput } from './output.ts';
+import { writeCommandMessage, writeCommandOutput } from './shared.ts';
 import type { PublicCommandName } from '../../command-catalog.ts';
 import type { ClientCommandHandler } from './router-types.ts';
 
@@ -37,6 +64,104 @@ export const genericClientCommandHandlers = Object.fromEntries(
   ]),
 ) as { [TCommand in keyof typeof genericClientCommandRunners]: ClientCommandHandler };
 
+const formattedSemanticCommandHandlers = {
+  devices: createFormattedSemanticHandler('devices', {
+    write: ({ flags, result }) => {
+      const devices = result as unknown as AgentDeviceDevice[];
+      const data = { devices: devices.map(serializeDevice) };
+      writeCommandOutput(flags, data, () => devices.map(formatDeviceLine).join('\n'));
+    },
+  }),
+  apps: createFormattedSemanticHandler('apps', {
+    write: ({ flags, result }) => {
+      const appsFilter = assertResolvedAppsFilter(flags.appsFilter);
+      const apps = result as unknown as string[];
+      const data = { apps };
+      writeCommandOutput(flags, data, () => {
+        if (!flags.json) {
+          process.stderr.write(
+            appsFilter === 'all'
+              ? 'Showing all apps, including system apps.\n'
+              : 'Showing user-installed apps. Use --all to include system apps.\n',
+          );
+        }
+        if (apps.length > 0) return apps.join('\n');
+        return appsFilter === 'all' ? 'No apps found.' : 'No user-installed apps found.';
+      });
+    },
+  }),
+  session: createFormattedSemanticHandler('session', {
+    beforeRun: ({ positionals }) => {
+      const subcommand = positionals[0] ?? 'list';
+      if (subcommand !== 'list') {
+        throw new AppError('INVALID_ARGS', 'session only supports list');
+      }
+    },
+    write: ({ flags, result }) => {
+      const sessions = (result as { sessions: AgentDeviceSession[] }).sessions;
+      const data = { sessions: sessions.map(serializeSessionListEntry) };
+      writeCommandOutput(flags, data, () => JSON.stringify(data, null, 2));
+    },
+  }),
+  open: createFormattedSemanticHandler('open', {
+    write: ({ flags, result }) => {
+      writeCommandMessage(flags, serializeOpenResult(result as AppOpenResult));
+    },
+  }),
+  close: createFormattedSemanticHandler('close', {
+    write: ({ flags, result }) => {
+      writeCommandMessage(
+        flags,
+        serializeCloseResult(result as AppCloseResult | SessionCloseResult),
+      );
+    },
+  }),
+  install: createFormattedSemanticHandler('install', {
+    write: ({ flags, result }) => {
+      writeCommandMessage(flags, serializeDeployResult(result as AppDeployResult));
+    },
+  }),
+  reinstall: createFormattedSemanticHandler('reinstall', {
+    write: ({ flags, result }) => {
+      writeCommandMessage(flags, serializeDeployResult(result as AppDeployResult));
+    },
+  }),
+  'install-from-source': createFormattedSemanticHandler('install-from-source', {
+    write: ({ flags, result }) => {
+      writeCommandMessage(
+        flags,
+        serializeInstallFromSourceResult(result as AppInstallFromSourceResult),
+      );
+    },
+  }),
+  snapshot: createFormattedSemanticHandler('snapshot', {
+    positionals: () => [],
+    write: ({ flags, result }) => {
+      const data = serializeSnapshotResult(result as CaptureSnapshotResult);
+      // Programmatic SDK callers can see `unchanged`; CLI --json hides it for schema compatibility.
+      const outputData = flags.json ? withoutUnchanged(data) : data;
+      writeCommandOutput(flags, outputData, () =>
+        formatSnapshotText(outputData, {
+          raw: flags.snapshotRaw,
+          flatten: flags.snapshotInteractiveOnly,
+        }),
+      );
+    },
+  }),
+  metro: createFormattedSemanticHandler('metro', {
+    write: ({ positionals, flags, result }) => {
+      const action = (positionals[0] ?? '').toLowerCase();
+      writeCommandOutput(flags, result, () =>
+        action === 'reload'
+          ? `Reloaded React Native apps via ${(result as { reloadUrl?: unknown }).reloadUrl}`
+          : JSON.stringify(result, null, 2),
+      );
+    },
+  }),
+} satisfies Partial<Record<SemanticCliCommand, ClientCommandHandler>>;
+
+export const dedicatedSemanticCommandHandlers = formattedSemanticCommandHandlers;
+
 function createGenericClientCommandHandler(
   command: PublicCommandName,
   run: GenericClientCommandRunner,
@@ -50,3 +175,41 @@ function createGenericClientCommandHandler(
     return true;
   };
 }
+
+function createFormattedSemanticHandler(
+  command: SemanticCliCommand,
+  options: {
+    positionals?: (positionals: string[]) => string[];
+    beforeRun?: (params: { positionals: string[]; flags: CliFlags }) => void;
+    write: (params: {
+      positionals: string[];
+      flags: CliFlags;
+      result: Awaited<ReturnType<typeof runSemanticCliCommand>>;
+    }) => void;
+  },
+): ClientCommandHandler {
+  return async ({ positionals, flags, client }) => {
+    options.beforeRun?.({ positionals, flags });
+    const semanticPositionals = options.positionals?.(positionals) ?? positionals;
+    const result = await runSemanticCliCommand({
+      client,
+      command,
+      positionals: semanticPositionals,
+      flags,
+    });
+    options.write({ positionals, flags, result });
+    return true;
+  };
+}
+
+function formatDeviceLine(device: AgentDeviceDevice): string {
+  const kind = device.kind ? ` ${device.kind}` : '';
+  const target = device.target ? ` target=${device.target}` : '';
+  const booted = typeof device.booted === 'boolean' ? ` booted=${device.booted}` : '';
+  return `${device.name} (${device.platform}${kind}${target})${booted}`;
+}
+
+function withoutUnchanged(data: Record<string, unknown>): Record<string, unknown> {
+  const { unchanged: _unchanged, ...outputData } = data;
+  return outputData;
+}

src/cli/commands/devices.ts

@@ -1,17 +1,10 @@
 import { applyCommandDefaults, type CliFlags } from '../../utils/command-schema.ts';
 import type { AgentDeviceClient } from '../../client.ts';
-import { sessionCommand } from './session.ts';
-import { devicesCommand } from './devices.ts';
-import { metroCommand } from './metro.ts';
-import { appsCommand } from './apps.ts';
-import { installCommand, reinstallCommand, installFromSourceCommand } from './install.ts';
-import { openCommand, closeCommand } from './open.ts';
 import { connectCommand, connectionCommand, disconnectCommand } from './connection.ts';
 import { authCommand } from './auth.ts';
-import { snapshotCommand } from './snapshot.ts';
 import { screenshotCommand, diffCommand } from './screenshot.ts';
 import { clientCommandMethodHandlers } from './client-command.ts';
-import { genericClientCommandHandlers } from './generic.ts';
+import { dedicatedSemanticCommandHandlers, genericClientCommandHandlers } from './generic.ts';
 import type { ClientCommandHandlerMap } from './router-types.ts';
 
 export type {
@@ -21,26 +14,17 @@ export type {
 } from './router-types.ts';
 
 const dedicatedCliCommandHandlers = {
-  session: sessionCommand,
-  devices: devicesCommand,
-  apps: appsCommand,
-  metro: metroCommand,
-  install: installCommand,
-  reinstall: reinstallCommand,
-  'install-from-source': installFromSourceCommand,
   connect: connectCommand,
   disconnect: disconnectCommand,
   connection: connectionCommand,
   auth: authCommand,
-  open: openCommand,
-  close: closeCommand,
-  snapshot: snapshotCommand,
   screenshot: screenshotCommand,
   diff: diffCommand,
 } satisfies ClientCommandHandlerMap;
 
 const clientCommandHandlers: ClientCommandHandlerMap = {
   ...dedicatedCliCommandHandlers,
+  ...dedicatedSemanticCommandHandlers,
   ...clientCommandMethodHandlers,
   ...genericClientCommandHandlers,
 };