rnxsim 0.0.0 → 0.1.313

package/src/settings-bundle.ts

@@ -0,0 +1,418 @@
+import { readFile, readdir, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { parsePlistSource } from './plist.ts'
+import type { AppPreferenceValue, AppSettingsSpecifier } from '@sootsim/globals'
+
+const MAX_PLIST_BYTES = 1_048_576
+const MAX_CHILD_DEPTH = 8
+const MAX_PLIST_FILES = 32
+const MAX_SPECIFIERS = 512
+
+type PlistRecord = Record<string, unknown>
+
+interface ParseBudget {
+  files: number
+  specifiers: number
+}
+
+interface CachedSettingsBundle {
+  fingerprint: string
+  specifiers: readonly AppSettingsSpecifier[] | null
+}
+
+const settingsBundleCache = new Map<string, CachedSettingsBundle>()
+
+function isRecord(value: unknown): value is PlistRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+function requiredString(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const normalized = value.trim()
+  return normalized ? normalized : null
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function preferenceValue(value: unknown): AppPreferenceValue | null {
+  if (typeof value === 'string' || typeof value === 'boolean') return value
+  return finiteNumber(value)
+}
+
+function keyboardType(
+  value: unknown,
+): Extract<AppSettingsSpecifier, { type: 'text' }>['keyboardType'] {
+  if (typeof value !== 'string') return undefined
+  switch (value.replaceAll(/[-_\s]/g, '').toLowerCase()) {
+    case 'alphabet':
+      return 'alphabet'
+    case 'numbersandpunctuation':
+      return 'numbers-and-punctuation'
+    case 'numberpad':
+      return 'number-pad'
+    case 'url':
+      return 'url'
+    case 'emailaddress':
+      return 'email-address'
+    case 'namephonepad':
+      return 'name-phone-pad'
+    case 'asciicapable':
+      return 'ascii-capable'
+    default:
+      return undefined
+  }
+}
+
+function autocapitalization(
+  value: unknown,
+): Extract<AppSettingsSpecifier, { type: 'text' }>['autocapitalization'] {
+  if (typeof value !== 'string') return undefined
+  switch (value.replaceAll(/[-_\s]/g, '').toLowerCase()) {
+    case 'none':
+      return 'none'
+    case 'sentences':
+      return 'sentences'
+    case 'words':
+      return 'words'
+    case 'allcharacters':
+      return 'all-characters'
+    default:
+      return undefined
+  }
+}
+
+function autocorrection(value: unknown): boolean | undefined {
+  if (typeof value === 'boolean') return value
+  if (typeof value !== 'string') return undefined
+  switch (value.trim().toLowerCase()) {
+    case 'yes':
+      return true
+    case 'no':
+      return false
+    default:
+      return undefined
+  }
+}
+
+function safeChildPlistName(value: unknown): { file: string; name: string } | null {
+  const file = requiredString(value)
+  if (!file || file.includes('/') || file.includes('\\') || file.includes('..')) {
+    return null
+  }
+  return {
+    file,
+    name: file.toLowerCase().endsWith('.plist') ? file : `${file}.plist`,
+  }
+}
+
+async function readableSettingsBundle(path: string): Promise<boolean> {
+  try {
+    const root = await stat(join(path, 'Root.plist'))
+    return root.isFile() && root.size <= MAX_PLIST_BYTES
+  } catch {
+    return false
+  }
+}
+
+async function findSettingsBundle(projectRoot: string): Promise<string | null> {
+  const directCandidates = [
+    join(projectRoot, 'Settings.bundle'),
+    join(projectRoot, 'ios', 'Settings.bundle'),
+  ]
+  for (const candidate of directCandidates) {
+    if (await readableSettingsBundle(candidate)) return candidate
+  }
+
+  try {
+    const iosRoot = join(projectRoot, 'ios')
+    const children = await readdir(iosRoot, { withFileTypes: true })
+    const candidates = children
+      .filter(
+        (entry) =>
+          entry.isDirectory() &&
+          entry.name !== 'Pods' &&
+          entry.name !== 'build' &&
+          !entry.name.startsWith('.'),
+      )
+      .map((entry) => join(iosRoot, entry.name, 'Settings.bundle'))
+      .sort()
+    for (const candidate of candidates) {
+      if (await readableSettingsBundle(candidate)) return candidate
+    }
+  } catch {}
+
+  return null
+}
+
+async function settingsBundleFingerprint(bundlePath: string): Promise<string | null> {
+  try {
+    const entries = await readdir(bundlePath, { withFileTypes: true })
+    const names = entries
+      .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith('.plist'))
+      .map((entry) => entry.name)
+      .sort()
+      .slice(0, MAX_PLIST_FILES + 1)
+    if (names.length === 0 || names.length > MAX_PLIST_FILES) return null
+
+    const parts = await Promise.all(
+      names.map(async (name) => {
+        const metadata = await stat(join(bundlePath, name))
+        if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null
+        return `${name}:${metadata.size}:${metadata.mtimeMs}:${metadata.ctimeMs}`
+      }),
+    )
+    if (parts.some((part) => part === null)) return null
+    return parts.join('|')
+  } catch {
+    return null
+  }
+}
+
+async function parsePlistRecord(path: string): Promise<PlistRecord | null> {
+  try {
+    const metadata = await stat(path)
+    if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null
+    const source = await readFile(path, 'utf8')
+    const parsed = parsePlistSource(source)
+    return isRecord(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+function normalizeMultiValue(
+  raw: PlistRecord,
+  key: string,
+  title: string,
+): AppSettingsSpecifier | null {
+  if (!Array.isArray(raw.Values) || !Array.isArray(raw.Titles)) return null
+  const values: AppPreferenceValue[] = []
+  const titles: string[] = []
+  let optionType: 'string' | 'number' | 'boolean' | undefined
+  const pairCount = Math.min(raw.Values.length, raw.Titles.length)
+  for (let index = 0; index < pairCount; index++) {
+    const value = preferenceValue(raw.Values[index])
+    const optionTitle = optionalString(raw.Titles[index])
+    if (value === null || optionTitle === undefined) continue
+    const valueType: 'string' | 'number' | 'boolean' =
+      typeof value === 'string'
+        ? 'string'
+        : typeof value === 'number'
+          ? 'number'
+          : 'boolean'
+    if (optionType !== undefined && valueType !== optionType) continue
+    optionType = valueType
+    values.push(value)
+    titles.push(optionTitle)
+  }
+  const firstValue = values[0]
+  if (firstValue === undefined) return null
+  const declaredDefault = preferenceValue(raw.DefaultValue)
+  const defaultValue =
+    declaredDefault !== null && values.includes(declaredDefault)
+      ? declaredDefault
+      : firstValue
+  return {
+    type: 'multi-value',
+    key,
+    title,
+    defaultValue,
+    currentValue: defaultValue,
+    values,
+    titles,
+  }
+}
+
+async function normalizeSpecifier(
+  raw: unknown,
+  context: {
+    bundlePath: string
+    depth: number
+    budget: ParseBudget
+    stack: ReadonlySet<string>
+    fileCache: Map<string, readonly AppSettingsSpecifier[] | null>
+  },
+): Promise<AppSettingsSpecifier | null> {
+  if (!isRecord(raw)) return null
+  if (context.budget.specifiers >= MAX_SPECIFIERS) return null
+  const type = requiredString(raw.Type)
+  if (!type) return null
+  context.budget.specifiers += 1
+
+  if (type === 'PSGroupSpecifier') {
+    const title = optionalString(raw.Title)
+    const footer = optionalString(raw.FooterText)
+    return {
+      type: 'group',
+      ...(title !== undefined ? { title } : null),
+      ...(footer !== undefined ? { footer } : null),
+    }
+  }
+
+  const key = requiredString(raw.Key)
+  if (type === 'PSSliderSpecifier') {
+    if (!key) return null
+    const minimumValue = finiteNumber(raw.MinimumValue)
+    const maximumValue = finiteNumber(raw.MaximumValue)
+    if (minimumValue === null || maximumValue === null || maximumValue <= minimumValue) {
+      return null
+    }
+    const declaredDefault = finiteNumber(raw.DefaultValue)
+    const defaultValue = Math.min(
+      maximumValue,
+      Math.max(minimumValue, declaredDefault ?? minimumValue),
+    )
+    const title = optionalString(raw.Title)
+    const minimumValueImage = optionalString(raw.MinimumValueImage)
+    const maximumValueImage = optionalString(raw.MaximumValueImage)
+    return {
+      type: 'slider',
+      key,
+      defaultValue,
+      currentValue: defaultValue,
+      minimumValue,
+      maximumValue,
+      ...(title !== undefined ? { title } : null),
+      ...(minimumValueImage !== undefined ? { minimumValueImage } : null),
+      ...(maximumValueImage !== undefined ? { maximumValueImage } : null),
+    }
+  }
+
+  if (type === 'PSChildPaneSpecifier') {
+    const title = requiredString(raw.Title)
+    const child = safeChildPlistName(raw.File)
+    if (!title || !child || context.depth >= MAX_CHILD_DEPTH) return null
+    const childSpecifiers = await parseSpecifierFile(child.name, {
+      ...context,
+      depth: context.depth + 1,
+    })
+    if (!childSpecifiers || childSpecifiers.length === 0) return null
+    return {
+      type: 'child-pane',
+      title,
+      file: child.file,
+      specifiers: childSpecifiers,
+    }
+  }
+
+  if (!key) return null
+  const title = requiredString(raw.Title) ?? key
+
+  if (type === 'PSToggleSwitchSpecifier') {
+    const defaultValue = typeof raw.DefaultValue === 'boolean' ? raw.DefaultValue : false
+    return {
+      type: 'toggle',
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue,
+    }
+  }
+
+  if (type === 'PSTextFieldSpecifier') {
+    const defaultValue = optionalString(raw.DefaultValue) ?? ''
+    const placeholder = optionalString(raw.Placeholder)
+    const resolvedKeyboardType = keyboardType(raw.KeyboardType)
+    const resolvedAutocapitalization = autocapitalization(raw.AutocapitalizationType)
+    const resolvedAutocorrection = autocorrection(raw.AutocorrectionType)
+    return {
+      type: 'text',
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue,
+      ...(placeholder !== undefined ? { placeholder } : null),
+      ...(typeof raw.IsSecure === 'boolean' ? { secure: raw.IsSecure } : null),
+      ...(resolvedKeyboardType ? { keyboardType: resolvedKeyboardType } : null),
+      ...(resolvedAutocapitalization
+        ? { autocapitalization: resolvedAutocapitalization }
+        : null),
+      ...(resolvedAutocorrection !== undefined
+        ? { autocorrection: resolvedAutocorrection }
+        : null),
+    }
+  }
+
+  if (type === 'PSMultiValueSpecifier' || type === 'PSRadioGroupSpecifier') {
+    return normalizeMultiValue(raw, key, title)
+  }
+
+  if (type === 'PSTitleValueSpecifier') {
+    const defaultValue = preferenceValue(raw.DefaultValue) ?? ''
+    return {
+      type: 'title-value',
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue,
+    }
+  }
+
+  return null
+}
+
+async function parseSpecifierFile(
+  fileName: string,
+  context: {
+    bundlePath: string
+    depth: number
+    budget: ParseBudget
+    stack: ReadonlySet<string>
+    fileCache: Map<string, readonly AppSettingsSpecifier[] | null>
+  },
+): Promise<readonly AppSettingsSpecifier[] | null> {
+  const cached = context.fileCache.get(fileName)
+  if (cached !== undefined) return cached
+  if (context.stack.has(fileName) || context.budget.files >= MAX_PLIST_FILES) {
+    return null
+  }
+  context.budget.files += 1
+  const root = await parsePlistRecord(join(context.bundlePath, fileName))
+  if (!root || !Array.isArray(root.PreferenceSpecifiers)) {
+    context.fileCache.set(fileName, null)
+    return null
+  }
+
+  const stack = new Set(context.stack)
+  stack.add(fileName)
+  const specifiers: AppSettingsSpecifier[] = []
+  for (const raw of root.PreferenceSpecifiers) {
+    if (context.budget.specifiers >= MAX_SPECIFIERS) break
+    const specifier = await normalizeSpecifier(raw, { ...context, stack })
+    if (specifier) specifiers.push(specifier)
+  }
+  context.fileCache.set(fileName, specifiers)
+  return specifiers
+}
+
+export async function readAppSettingsBundle(
+  projectRoot: string,
+): Promise<readonly AppSettingsSpecifier[] | null> {
+  const bundlePath = await findSettingsBundle(projectRoot)
+  if (!bundlePath) return null
+  const fingerprint = await settingsBundleFingerprint(bundlePath)
+  if (!fingerprint) return null
+  const cached = settingsBundleCache.get(bundlePath)
+  if (cached?.fingerprint === fingerprint) return cached.specifiers
+
+  const specifiers = await parseSpecifierFile('Root.plist', {
+    bundlePath,
+    depth: 0,
+    budget: { files: 0, specifiers: 0 },
+    stack: new Set(),
+    fileCache: new Map(),
+  })
+  const normalized = specifiers && specifiers.length > 0 ? specifiers : null
+  settingsBundleCache.set(bundlePath, { fingerprint, specifiers: normalized })
+  return normalized
+}
+
+export function __resetAppSettingsBundleCacheForTests(): void {
+  settingsBundleCache.clear()
+}

package/src/skills/builtin/a11y-review.ts

@@ -0,0 +1,132 @@
+// built-in skill: accessibility audit
+
+import { launchReapedChrome } from '../../../../../scripts/lib/reap-browser'
+import type { SootSimSkill } from '../types'
+
+export const skill: SootSimSkill = {
+  name: 'a11y-review',
+  description: 'Check the app for accessibility issues',
+  type: 'review',
+  version: '1.0.0',
+  triggers: ['accessibility', 'a11y', 'check accessibility', 'audit accessibility'],
+  tools: [
+    {
+      name: 'audit_accessibility',
+      description: 'Run an accessibility audit on the current screen',
+      parameters: {
+        screen: { type: 'string', description: 'Screen name or URL to audit' },
+      },
+      async execute(params, context) {
+        const { chromium } = await import('playwright')
+        const path = await import('path')
+        const fs = await import('fs')
+
+        // sootsim renders CanvasKit — require GPU-backed Chrome (Metal). the
+        // bundled swiftshader shell software-renders the canvas and pegs every
+        // core; never use it for sootsim.
+        const browser = await launchReapedChrome((options) => chromium.launch(options), {
+          headless: true,
+        })
+        const page = await browser.newPage({ viewport: { width: 500, height: 900 } })
+
+        try {
+          await page.goto(context.url, { waitUntil: 'networkidle' })
+          await page.waitForFunction('window.__sootsimTest', { timeout: 10000 })
+          await page.waitForTimeout(2000)
+
+          // get accessibility tree
+          const tree = await page.evaluate(
+            'window.__sootsimTest.dumpAccessibilityTree(10)',
+          )
+          const allNodes = await page.evaluate('window.__sootsimTest.queryAll({})')
+
+          // analyze for common issues
+          const issues: {
+            severity: 'error' | 'warning' | 'info'
+            message: string
+            node?: string
+          }[] = []
+
+          if (Array.isArray(allNodes)) {
+            for (const node of allNodes) {
+              // check for missing accessibility labels on interactive elements
+              if (
+                (node.accessibilityRole === 'button' ||
+                  node.accessibilityRole === 'link' ||
+                  node.type === 'TouchableOpacity' ||
+                  node.type === 'Pressable') &&
+                !node.accessibilityLabel &&
+                !node.text
+              ) {
+                issues.push({
+                  severity: 'error',
+                  message: `Interactive element missing accessibility label`,
+                  node: node.testID || node.id || node.type,
+                })
+              }
+
+              // check for missing roles
+              if (
+                (node.type === 'TouchableOpacity' || node.type === 'Pressable') &&
+                !node.accessibilityRole
+              ) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Touchable element missing accessibility role`,
+                  node: node.testID || node.id || node.type,
+                })
+              }
+
+              // check for images without alt text
+              if (node.type === 'Image' && !node.accessibilityLabel && !node.accessible) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Image missing accessibility label`,
+                  node: node.testID || node.id || 'Image',
+                })
+              }
+
+              // check for small touch targets
+              if (
+                node.layout &&
+                (node.accessibilityRole === 'button' ||
+                  node.type === 'TouchableOpacity') &&
+                (node.layout.width < 44 || node.layout.height < 44)
+              ) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Touch target too small (${Math.round(node.layout.width)}x${Math.round(node.layout.height)}pt, minimum 44x44pt)`,
+                  node: node.testID || node.text || node.type,
+                })
+              }
+            }
+          }
+
+          // write report
+          const report = {
+            timestamp: new Date().toISOString(),
+            screen: params.screen || 'current',
+            nodeCount: Array.isArray(allNodes) ? allNodes.length : 0,
+            issues,
+            errors: issues.filter((i) => i.severity === 'error').length,
+            warnings: issues.filter((i) => i.severity === 'warning').length,
+            tree: typeof tree === 'string' ? tree : JSON.stringify(tree),
+          }
+
+          const reportPath = path.join(context.outputDir, 'a11y-report.json')
+          fs.mkdirSync(path.dirname(reportPath), { recursive: true })
+          fs.writeFileSync(reportPath, JSON.stringify(report, null, 2))
+
+          return {
+            success: issues.filter((i) => i.severity === 'error').length === 0,
+            message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
+            artifacts: [{ type: 'report', name: 'a11y-report', path: reportPath }],
+            data: report,
+          }
+        } finally {
+          await browser.close()
+        }
+      },
+    },
+  ],
+}

package/src/skills/builtin/compat-check.ts

@@ -0,0 +1,71 @@
+// built-in skill: package compatibility check
+
+import type { SootSimSkill } from '../types'
+
+export const skill: SootSimSkill = {
+  name: 'compat-check',
+  description: 'Check package compatibility with rnx',
+  type: 'review',
+  version: '1.0.0',
+  triggers: ['compatibility', 'compat', 'check package', 'supported packages'],
+  tools: [
+    {
+      name: 'check_compatibility',
+      description: 'Scan project dependencies for rnx compatibility',
+      parameters: {
+        packageName: {
+          type: 'string',
+          description: 'Specific package to check (optional)',
+        },
+      },
+      async execute(params, context) {
+        const fs = await import('node:fs')
+        const path = await import('node:path')
+        const { COMPAT_RESULT_CAVEAT, formatPackageStatus, formatScanCounts, scanDeps } =
+          await import('../../../../compat/src/web.ts')
+
+        const packagePath = path.join(context.projectDir, 'package.json')
+        if (!fs.existsSync(packagePath)) {
+          return { success: false, message: 'No package.json found' }
+        }
+        const parsed: unknown = JSON.parse(fs.readFileSync(packagePath, 'utf8'))
+        if (!parsed || typeof parsed !== 'object') {
+          return { success: false, message: 'package.json is not an object' }
+        }
+
+        const dependencies = readDependencies(parsed)
+        const scan = params.packageName
+          ? scanDeps({
+              dependencies: {
+                [params.packageName]: dependencies[params.packageName] ?? '*',
+              },
+            })
+          : scanDeps(parsed)
+        const packageResult = params.packageName ? scan.packages[0] : undefined
+        const message = packageResult
+          ? `${params.packageName}: ${formatPackageStatus(packageResult)}. ${COMPAT_RESULT_CAVEAT}`
+          : `${formatScanCounts(scan)}. ${COMPAT_RESULT_CAVEAT}`
+
+        const reportPath = path.join(context.outputDir, 'compat-report.json')
+        fs.mkdirSync(path.dirname(reportPath), { recursive: true })
+        fs.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}\n`)
+
+        return {
+          success: true,
+          message,
+          artifacts: [{ type: 'report', name: 'compat-report', path: reportPath }],
+          data: scan,
+        }
+      },
+    },
+  ],
+}
+
+function readDependencies(value: object): Record<string, string> {
+  const dependencies = Reflect.get(value, 'dependencies')
+  const devDependencies = Reflect.get(value, 'devDependencies')
+  return {
+    ...(dependencies && typeof dependencies === 'object' ? dependencies : {}),
+    ...(devDependencies && typeof devDependencies === 'object' ? devDependencies : {}),
+  }
+}