Function dispatchWaitViaRuntime

src/daemon/selector-runtime.ts:197–242

(
  params: SelectorRuntimeParams,
)

}

export async function dispatchWaitViaRuntime(
  params: SelectorRuntimeParams,
): Promise<DaemonResponse> {
  const { req, sessionName, sessionStore } = params;
  const parsed = parseWaitPositionals(req.positionals ?? []);
  if (!parsed) return errorResponse('INVALID_ARGS', 'wait requires a duration or text');
  const { session, device } = await resolveSessionDevice(sessionStore, sessionName, req.flags);
  if (parsed.kind !== 'sleep') {
    const unsupported = requireCommandSupported('wait', device);
    if (unsupported) return unsupported;
  }
  if (parsed.kind === 'selector') {
    const directResponse = await dispatchDirectIosSelectorWait({
      ...params,
      session,
      device,
      selectorExpression: parsed.selectorExpression,
      timeoutMs: parsed.timeoutMs,
    });
    if (directResponse) return directResponse;
  }
  const execute = async () => {
    const runtime = createSelectorRuntimeForDevice({
      ...params,
      session,
      device,
    });
    const response = await toDaemonResponse(async () => {
      const result = await runtime.selectors.wait({
        session: sessionName,
        requestId: req.meta?.requestId,
        target: toWaitTarget(parsed, session),
      });
      recordIfSession(sessionStore, sessionName, req, result);
      return toDaemonWaitData(result);
    });
    const enrichedResponse = await maybeWaitTimeoutSurfaceResponse(
      { req, logPath: params.logPath, session, device },
      response,
    );
    // Keep generic wait-surface details first so Android blocker detection can own the top-level message.
    return await maybeAndroidForegroundBlockerResponse(params, enrichedResponse, 'wait');
  };
  if (parsed.kind === 'sleep') return await execute();
  return await withSessionlessRunnerCleanup(session, device, execute);
}

async function dispatchDirectIosSelectorGet(
  params: SelectorRuntimeParams,