voltra 2.0.0 → 2.1.1

package/src/platforms/ios/mainAppEntitlements.ts

@@ -0,0 +1,11 @@
+import path from 'node:path'
+
+import type { IOSProjectDiscovery } from '../../discovery/ios'
+
+export function resolveMainAppEntitlementsPath(discovery: IOSProjectDiscovery): string {
+  if (discovery.entitlementsPath) {
+    return discovery.entitlementsPath
+  }
+
+  return path.join(path.dirname(discovery.infoPlistPath), `${discovery.mainTargetName}.entitlements`)
+}

package/src/platforms/ios/plist.ts

@@ -0,0 +1,321 @@
+import { parseStringPromise } from 'xml2js'
+
+import { readTextFile, writeTextFile } from '../../fs/readWrite'
+import { toRelativePath } from '../../fs/path'
+import { VoltraCliError } from '../../reporting/summary'
+
+import type { IOSProjectDiscovery } from '../../discovery/ios'
+import type { NormalizedVoltraIOSConfig } from '../../config/types'
+import type { ReportedChange } from '../../reporting/summary'
+
+interface OrderedPlistNode {
+  '#name'?: string
+  _?: string
+  $$?: OrderedPlistNode[]
+}
+
+interface TaggedPlistScalar {
+  __voltraPlistScalarType: 'data' | 'date'
+  value: string
+}
+
+type PlistErrorFactory = (message: string) => Error
+
+export interface EnsureInfoPlistOptions {
+  projectRoot: string
+  ios: NormalizedVoltraIOSConfig
+  discovery: IOSProjectDiscovery
+}
+
+export interface EnsureInfoPlistResult {
+  change?: ReportedChange
+}
+
+export class IOSInfoPlistMutationError extends VoltraCliError {
+  constructor(message: string) {
+    super(message, 'VOLTRA_IOS_INFO_PLIST_FAILED')
+    this.name = 'IOSInfoPlistMutationError'
+  }
+}
+
+export async function ensureInfoPlist(options: EnsureInfoPlistOptions): Promise<EnsureInfoPlistResult> {
+  const { projectRoot, ios, discovery } = options
+  const infoPlist = await parsePlistFile(discovery.infoPlistPath, 'main app Info.plist', createInfoPlistError)
+
+  infoPlist.NSSupportsLiveActivities = true
+  infoPlist.NSSupportsLiveActivitiesFrequentUpdates = false
+
+  setOrDeleteVoltraKey(infoPlist, 'Voltra_AppGroupIdentifier', ios.groupIdentifier)
+  setOrDeleteVoltraKey(infoPlist, 'Voltra_KeychainGroup', ios.keychainGroup)
+  setOrDeleteVoltraKey(infoPlist, 'Voltra_EnablePushNotifications', ios.enablePushNotifications ? true : undefined)
+
+  const widgetIds = ios.widgets.map((widget) => widget.id)
+  setOrDeleteVoltraKey(infoPlist, 'Voltra_WidgetIds', widgetIds.length > 0 ? widgetIds : undefined)
+
+  const serverWidgets = ios.widgets.filter((widget) => widget.serverUpdate)
+  const serverUrls = Object.fromEntries(serverWidgets.map((widget) => [widget.id, widget.serverUpdate?.url]))
+  const serverIntervals = Object.fromEntries(
+    serverWidgets.map((widget) => [widget.id, widget.serverUpdate?.intervalMinutes])
+  )
+
+  setOrDeleteVoltraKey(
+    infoPlist,
+    'Voltra_WidgetServerUrls',
+    Object.keys(serverUrls).length > 0 ? serverUrls : undefined
+  )
+  setOrDeleteVoltraKey(
+    infoPlist,
+    'Voltra_WidgetServerIntervals',
+    Object.keys(serverIntervals).length > 0 ? serverIntervals : undefined
+  )
+
+  const nextContent = buildPlistXml(infoPlist, createInfoPlistError)
+  const change = await writePlistIfChanged(projectRoot, discovery.infoPlistPath, nextContent)
+
+  return { change }
+}
+
+export async function parsePlistFile(
+  filePath: string,
+  errorContext: string,
+  createError: PlistErrorFactory
+): Promise<Record<string, unknown>> {
+  let content: string
+
+  try {
+    content = await readTextFile(filePath)
+  } catch (error: unknown) {
+    throw createError(`Failed to read ${errorContext} at ${filePath}: ${getErrorMessage(error)}`)
+  }
+
+  let parsed: unknown
+
+  try {
+    parsed = await parseStringPromise(content, {
+      explicitArray: false,
+      explicitChildren: true,
+      preserveChildrenOrder: true,
+    })
+  } catch (error: unknown) {
+    throw createError(`Failed to parse ${errorContext} at ${filePath}: ${getErrorMessage(error)}`)
+  }
+
+  const plistRoot = getPlistRoot(parsed, errorContext, filePath, createError)
+  return parsePlistDict(plistRoot, errorContext, filePath, createError)
+}
+
+export function buildPlistXml(value: unknown, createError: PlistErrorFactory): string {
+  try {
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+      '<plist version="1.0">',
+      renderPlistValue(value, 0, createError),
+      '</plist>',
+      '',
+    ].join('\n')
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw error
+    }
+
+    throw createError(`Failed to build plist XML: ${String(error)}`)
+  }
+}
+
+function getPlistRoot(
+  value: unknown,
+  errorContext: string,
+  filePath: string,
+  createError: PlistErrorFactory
+): OrderedPlistNode {
+  if (!value || typeof value !== 'object' || !('plist' in value)) {
+    throw createError(`Parsed ${errorContext} at ${filePath} is missing the plist root.`)
+  }
+
+  const plistValue = (value as { plist?: { dict?: unknown } }).plist
+
+  if (!plistValue || typeof plistValue !== 'object' || !('dict' in plistValue)) {
+    throw createError(`Parsed ${errorContext} at ${filePath} is missing the root dict.`)
+  }
+
+  if (!plistValue.dict || typeof plistValue.dict !== 'object') {
+    throw createError(`Parsed ${errorContext} at ${filePath} contains an invalid root dict.`)
+  }
+
+  return plistValue.dict as OrderedPlistNode
+}
+
+function parsePlistDict(
+  node: OrderedPlistNode,
+  errorContext: string,
+  filePath: string,
+  createError: PlistErrorFactory
+): Record<string, unknown> {
+  const children = getOrderedChildren(node)
+  const result: Record<string, unknown> = {}
+
+  for (let index = 0; index < children.length; index += 2) {
+    const keyNode = children[index]
+    const valueNode = children[index + 1]
+
+    if (keyNode?.['#name'] !== 'key' || typeof keyNode._ !== 'string' || keyNode._.trim().length === 0) {
+      throw createError(`Parsed ${errorContext} at ${filePath} contains an invalid dict key.`)
+    }
+
+    if (!valueNode) {
+      throw createError(`Parsed ${errorContext} at ${filePath} is missing a value for key '${keyNode._}'.`)
+    }
+
+    result[keyNode._] = parsePlistValue(valueNode, errorContext, filePath, createError)
+  }
+
+  return result
+}
+
+function parsePlistArray(
+  node: OrderedPlistNode,
+  errorContext: string,
+  filePath: string,
+  createError: PlistErrorFactory
+): unknown[] {
+  return getOrderedChildren(node).map((child) => parsePlistValue(child, errorContext, filePath, createError))
+}
+
+function parsePlistValue(
+  node: OrderedPlistNode,
+  errorContext: string,
+  filePath: string,
+  createError: PlistErrorFactory
+): unknown {
+  switch (node['#name']) {
+    case 'string':
+      return node._ ?? ''
+    case 'integer':
+    case 'real': {
+      const rawValue = node._ ?? ''
+      const numericValue = Number(rawValue)
+
+      if (!Number.isFinite(numericValue)) {
+        throw createError(
+          `Parsed ${errorContext} at ${filePath} contains an invalid ${node['#name']} value '${rawValue}'.`
+        )
+      }
+
+      return numericValue
+    }
+    case 'true':
+      return true
+    case 'false':
+      return false
+    case 'dict':
+      return parsePlistDict(node, errorContext, filePath, createError)
+    case 'array':
+      return parsePlistArray(node, errorContext, filePath, createError)
+    case 'data':
+      return { __voltraPlistScalarType: 'data', value: node._ ?? '' } satisfies TaggedPlistScalar
+    case 'date':
+      return { __voltraPlistScalarType: 'date', value: node._ ?? '' } satisfies TaggedPlistScalar
+    default:
+      throw createError(
+        `Parsed ${errorContext} at ${filePath} contains unsupported plist node '${node['#name'] ?? 'unknown'}'.`
+      )
+  }
+}
+
+function getOrderedChildren(node: OrderedPlistNode): OrderedPlistNode[] {
+  return Array.isArray(node.$$) ? node.$$ : []
+}
+
+function renderPlistValue(value: unknown, indentLevel: number, createError: PlistErrorFactory): string {
+  const indent = '  '.repeat(indentLevel)
+
+  if (Array.isArray(value)) {
+    const items = value.map((item) => renderPlistValue(item, indentLevel + 1, createError)).join('\n')
+    return `${indent}<array>\n${items}\n${indent}</array>`
+  }
+
+  if (isTaggedPlistScalar(value)) {
+    return `${indent}<${value.__voltraPlistScalarType}>${escapePlistText(value.value)}</${
+      value.__voltraPlistScalarType
+    }>`
+  }
+
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== undefined)
+    const lines = entries.flatMap(([key, entryValue]) => [
+      `${indent}  <key>${escapePlistText(key)}</key>`,
+      renderPlistValue(entryValue, indentLevel + 1, createError),
+    ])
+    return `${indent}<dict>\n${lines.join('\n')}\n${indent}</dict>`
+  }
+
+  if (typeof value === 'string') {
+    return `${indent}<string>${escapePlistText(value)}</string>`
+  }
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? `${indent}<integer>${value}</integer>` : `${indent}<real>${value}</real>`
+  }
+
+  if (typeof value === 'boolean') {
+    return `${indent}<${value ? 'true' : 'false'}/>`
+  }
+
+  if (value === null || value === undefined) {
+    throw createError('Cannot encode null or undefined in plist output.')
+  }
+
+  throw createError(`Unsupported plist value type: ${typeof value}`)
+}
+
+function isTaggedPlistScalar(value: unknown): value is TaggedPlistScalar {
+  return (
+    !!value &&
+    typeof value === 'object' &&
+    '__voltraPlistScalarType' in value &&
+    ((value as TaggedPlistScalar).__voltraPlistScalarType === 'data' ||
+      (value as TaggedPlistScalar).__voltraPlistScalarType === 'date') &&
+    typeof (value as TaggedPlistScalar).value === 'string'
+  )
+}
+
+function setOrDeleteVoltraKey(target: Record<string, unknown>, key: string, value: unknown): void {
+  if (value === undefined) {
+    delete target[key]
+    return
+  }
+
+  target[key] = value
+}
+
+async function writePlistIfChanged(
+  projectRoot: string,
+  plistPath: string,
+  nextContent: string
+): Promise<ReportedChange | undefined> {
+  const previousContent = await readTextFile(plistPath)
+
+  if (previousContent === nextContent) {
+    return undefined
+  }
+
+  await writeTextFile(plistPath, nextContent)
+
+  return {
+    kind: 'updated',
+    path: toRelativePath(projectRoot, plistPath),
+  }
+}
+
+function escapePlistText(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function createInfoPlistError(message: string): IOSInfoPlistMutationError {
+  return new IOSInfoPlistMutationError(message)
+}

package/src/platforms/ios/podfile.ts

@@ -0,0 +1,255 @@
+import path from 'node:path'
+import { createRequire } from 'node:module'
+
+import { readTextFile, writeTextFile } from '../../fs/readWrite'
+import { toRelativePath } from '../../fs/path'
+import { VoltraCliError } from '../../reporting/summary'
+import { resolveIOSWidgetTargetName } from './targetName'
+import { VOLTRA_MIN_IOS_DEPLOYMENT_TARGET, isIOSDeploymentTargetAtLeast } from './deploymentTarget'
+
+import type { IOSProjectDiscovery } from '../../discovery/ios'
+import type { NormalizedVoltraIOSConfig } from '../../config/types'
+import type { ReportedChange } from '../../reporting/summary'
+
+const VOLTRA_MANAGED_BLOCK_START = '# >>> VOLTRA MANAGED BLOCK: widget extension target'
+const VOLTRA_MANAGED_BLOCK_END = '# <<< VOLTRA MANAGED BLOCK: widget extension target'
+const LEGACY_BLOCK_HEADER = '# Voltra Widget Extension Target'
+const LEGACY_BLOCK_NOTICE = '# DO NOT MODIFY THIS FILE - IT IS AUTO-GENERATED BY THE VOLTRA PLUGIN'
+
+export interface EnsurePodfileBlockOptions {
+  projectRoot: string
+  ios: NormalizedVoltraIOSConfig
+  discovery: IOSProjectDiscovery
+}
+
+export interface EnsurePodfileBlockResult {
+  change?: ReportedChange
+  targetName: string
+  warnings?: string[]
+}
+
+export class IOSPodfileMutationError extends VoltraCliError {
+  constructor(message: string) {
+    super(message, 'VOLTRA_IOS_PODFILE_FAILED')
+    this.name = 'IOSPodfileMutationError'
+  }
+}
+
+export async function ensurePodfileBlock(options: EnsurePodfileBlockOptions): Promise<EnsurePodfileBlockResult> {
+  const { projectRoot, ios, discovery } = options
+  const targetName = resolveIOSWidgetTargetName(ios, discovery)
+  const currentContent = await readPodfile(discovery.podfilePath)
+  const nextBlock = buildManagedPodfileBlock(targetName)
+  const platformResult = await ensurePodfileDeploymentTarget(currentContent, projectRoot)
+  const nextContent = reconcilePodfile(platformResult.content, nextBlock, targetName)
+
+  if (currentContent === nextContent) {
+    return { targetName, warnings: platformResult.warnings }
+  }
+
+  await writeTextFile(discovery.podfilePath, nextContent)
+
+  return {
+    change: {
+      kind: 'updated',
+      path: toRelativePath(projectRoot, discovery.podfilePath),
+    },
+    targetName,
+    warnings: platformResult.warnings,
+  }
+}
+
+interface EnsurePodfileDeploymentTargetResult {
+  content: string
+  warnings?: string[]
+}
+
+async function ensurePodfileDeploymentTarget(
+  content: string,
+  projectRoot: string
+): Promise<EnsurePodfileDeploymentTargetResult> {
+  const lines = content.split('\n')
+  const platformLineIndex = lines.findIndex((line) => /^\s*platform\s+:ios\s*,/.test(line))
+
+  if (platformLineIndex === -1) {
+    return {
+      content,
+      warnings: [
+        `Could not find an iOS platform declaration in the Podfile. Ensure it resolves to iOS ${VOLTRA_MIN_IOS_DEPLOYMENT_TARGET} or newer.`,
+      ],
+    }
+  }
+
+  const line = lines[platformLineIndex]
+  const match = line.match(/^(\s*platform\s+:ios\s*,\s*)(.*?)(\s*(?:#.*)?)$/)
+
+  if (!match) {
+    return {
+      content,
+      warnings: [getUnknownPodfilePlatformWarning()],
+    }
+  }
+
+  const [, prefix, rawValue, suffix] = match
+  const platformValue = rawValue.trim()
+  const nextValue = await resolveNextPodfilePlatformValue(platformValue, projectRoot)
+
+  if (nextValue === undefined) {
+    return {
+      content,
+      warnings: [getUnknownPodfilePlatformWarning()],
+    }
+  }
+
+  if (nextValue === platformValue) {
+    return { content }
+  }
+
+  lines[platformLineIndex] = `${prefix}${nextValue}${suffix}`
+  return { content: lines.join('\n') }
+}
+
+async function resolveNextPodfilePlatformValue(
+  platformValue: string,
+  projectRoot: string
+): Promise<string | undefined> {
+  const literalVersion = parseRubyStringLiteral(platformValue)
+
+  if (literalVersion) {
+    return isIOSDeploymentTargetAtLeast(literalVersion, VOLTRA_MIN_IOS_DEPLOYMENT_TARGET)
+      ? platformValue
+      : `'${VOLTRA_MIN_IOS_DEPLOYMENT_TARGET}'`
+  }
+
+  if (platformValue === 'min_ios_version_supported') {
+    const reactNativeMinVersion = await resolveReactNativeMinIOSVersion(projectRoot)
+
+    if (
+      reactNativeMinVersion &&
+      isIOSDeploymentTargetAtLeast(reactNativeMinVersion, VOLTRA_MIN_IOS_DEPLOYMENT_TARGET)
+    ) {
+      return platformValue
+    }
+
+    return `'${VOLTRA_MIN_IOS_DEPLOYMENT_TARGET}'`
+  }
+
+  return undefined
+}
+
+function parseRubyStringLiteral(value: string): string | undefined {
+  const match = value.match(/^(['"])(\d+(?:\.\d+){0,2})\1$/)
+  return match?.[2]
+}
+
+async function resolveReactNativeMinIOSVersion(projectRoot: string): Promise<string | undefined> {
+  try {
+    const requireFromProject = createRequire(path.join(projectRoot, 'package.json'))
+    const reactNativePackagePath = requireFromProject.resolve('react-native/package.json')
+    const helpersPath = path.join(path.dirname(reactNativePackagePath), 'scripts', 'cocoapods', 'helpers.rb')
+    const helpersContent = await readTextFile(helpersPath)
+    return helpersContent.match(/def self\.min_ios_version_supported[\s\S]*?return ['"]([^'"]+)['"]/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+function getUnknownPodfilePlatformWarning(): string {
+  return `Could not verify the Podfile iOS platform declaration. Ensure it resolves to iOS ${VOLTRA_MIN_IOS_DEPLOYMENT_TARGET} or newer.`
+}
+
+function buildManagedPodfileBlock(targetName: string): string {
+  const escapedTargetName = escapeRubySingleQuotedString(targetName)
+
+  return [
+    VOLTRA_MANAGED_BLOCK_START,
+    '# Voltra widget extension target managed by voltra apply.',
+    `target '${escapedTargetName}' do`,
+    "  use_frameworks! :linkage => podfile_properties['ios.useFrameworks'].to_sym if defined?(podfile_properties) && podfile_properties['ios.useFrameworks']",
+    "  use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym if ENV['USE_FRAMEWORKS']",
+    '',
+    "  require 'pathname'",
+    '  project_root = "#{Pod::Config.instance.installation_root}/.."',
+    "  abort('[voltra] Error: @use-voltra/ios-client must be installed in the app project before running pod install.') unless system(\"node --print \\\"require.resolve('@use-voltra/ios-client/package.json', {paths: ['#{project_root}']})\\\" >/dev/null 2>&1\")",
+    "  voltra_client_root = `node --print \"require.resolve('@use-voltra/ios-client/package.json', {paths: ['#{project_root}']})\" 2>/dev/null`.strip.gsub('/package.json', '')",
+    "  voltra_widget_podspec_root = File.join(voltra_client_root, 'ios')",
+    '  podspec_dir_path = Pathname.new(voltra_widget_podspec_root).relative_path_from(Pathname.new(__dir__)).to_path',
+    '',
+    "  pod 'VoltraWidget', :path => podspec_dir_path",
+    'end',
+    VOLTRA_MANAGED_BLOCK_END,
+  ].join('\n')
+}
+
+function reconcilePodfile(currentContent: string, nextBlock: string, targetName: string): string {
+  const normalizedContent = stripTrailingWhitespace(currentContent)
+  const managedBlockPattern = createManagedBlockPattern()
+  const legacyBlockPattern = createLegacyBlockPattern()
+
+  if (managedBlockPattern.test(normalizedContent)) {
+    return ensureTrailingNewline(normalizedContent.replace(managedBlockPattern, nextBlock))
+  }
+
+  if (legacyBlockPattern.test(normalizedContent)) {
+    return ensureTrailingNewline(normalizedContent.replace(legacyBlockPattern, nextBlock))
+  }
+
+  if (hasUnmanagedTargetBlock(normalizedContent, targetName)) {
+    throw new IOSPodfileMutationError(
+      `Podfile already contains an unmanaged target '${targetName}'. Remove it or choose a different ios.targetName before running voltra apply.`
+    )
+  }
+
+  const separator = normalizedContent.length === 0 ? '' : '\n\n'
+  return ensureTrailingNewline(`${normalizedContent}${separator}${nextBlock}`)
+}
+
+function createManagedBlockPattern(): RegExp {
+  return new RegExp(
+    `${escapeRegExp(VOLTRA_MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(VOLTRA_MANAGED_BLOCK_END)}`,
+    'm'
+  )
+}
+
+function createLegacyBlockPattern(): RegExp {
+  return new RegExp(
+    `${escapeRegExp(LEGACY_BLOCK_HEADER)}\\n${escapeRegExp(LEGACY_BLOCK_NOTICE)}\\ntarget '[^']+' do[\\s\\S]*?\\nend`,
+    'm'
+  )
+}
+
+async function readPodfile(podfilePath: string): Promise<string> {
+  try {
+    return await readTextFile(podfilePath)
+  } catch (error: unknown) {
+    throw new IOSPodfileMutationError(`Failed to read Podfile at ${podfilePath}: ${getErrorMessage(error)}`)
+  }
+}
+
+function stripTrailingWhitespace(value: string): string {
+  return value.replace(/\s+$/, '')
+}
+
+function ensureTrailingNewline(value: string): string {
+  return `${value}\n`
+}
+
+function escapeRubySingleQuotedString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function hasUnmanagedTargetBlock(content: string, targetName: string): boolean {
+  const targetPattern = new RegExp(
+    `(^|\\n)target '${escapeRegExp(escapeRubySingleQuotedString(targetName))}' do(\\n|$)`,
+    'm'
+  )
+  return targetPattern.test(content)
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}

package/src/platforms/ios/targetName.ts

@@ -0,0 +1,11 @@
+import type { IOSProjectDiscovery } from '../../discovery/ios'
+import type { NormalizedVoltraIOSConfig } from '../../config/types'
+
+export function resolveIOSWidgetTargetName(ios: NormalizedVoltraIOSConfig, discovery: IOSProjectDiscovery): string {
+  if (ios.targetName) {
+    return ios.targetName
+  }
+
+  const sanitizedTargetName = discovery.mainTargetName.replace(/[^A-Za-z0-9_]/g, '')
+  return `${sanitizedTargetName}LiveActivity`
+}