flu-cli 2.0.6 → 2.1.0

package/lib/commands/upload.js

@@ -0,0 +1,313 @@
+import {
+  intro,
+  outro,
+  select,
+  text,
+  confirm,
+  spinner,
+  note,
+  isCancel,
+  cancel,
+} from '@clack/prompts'
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import {
+  ConfigValidator,
+  AndroidBuilder,
+  IOSBuilder,
+  PgyerUploader,
+  HuaweiUploader,
+  XiaomiUploader,
+  AppleStoreUploader,
+  TestFlightUploader,
+  AdHocUploader,
+  UploadManager,
+} from 'flu-cli-core'
+
+import { logger } from '../utils/logger.js'
+
+const CONFIG_FILE = 'flu_release.yaml'
+
+export async function uploadCommand(options) {
+  console.clear()
+  intro(chalk.bgCyan(' FLU UPLOAD '))
+
+  const cwd = process.cwd()
+  const configPath = path.join(cwd, CONFIG_FILE)
+
+  // 1. Check Config
+  if (!fs.existsSync(configPath)) {
+    note(`Config file not found: ${CONFIG_FILE}`, 'Info')
+    const shouldInit = await confirm({
+      message: 'Do you want to initialize a configuration file?',
+    })
+
+    if (isCancel(shouldInit) || !shouldInit) {
+      cancel('Operation cancelled.')
+      return process.exit(0)
+    }
+
+    await initConfig(configPath)
+    outro('Configuration file created. Please edit it and run upload again.')
+    return process.exit(0)
+  }
+
+  // 2. Validate Config
+  const s = spinner()
+  s.start('Validating configuration...')
+  const config = ConfigValidator.loadAndValidate(configPath)
+
+  if (!config) {
+    s.stop(chalk.red('Configuration invalid.'))
+    cancel('Please check your verification logs above.')
+    return process.exit(1)
+  }
+  s.stop('Configuration valid.')
+
+  // 3. Runtime Specs (Version, Changelog)
+  const pubspecPath = path.join(cwd, 'pubspec.yaml')
+  let currentVersion = '1.0.0'
+  let appMetadata = {
+    version: currentVersion,
+    changelog: '',
+    buildNumber: '1',
+    platform: [],
+  }
+
+  if (fs.existsSync(pubspecPath)) {
+    const pubspec = fs.readFileSync(pubspecPath, 'utf8')
+    const match = pubspec.match(/version:\s+([\d\.]+)(\+(\d+))?/)
+    if (match) {
+      currentVersion = match[1]
+      appMetadata.buildNumber = match[3] || '1'
+    }
+  }
+
+  // Version Bump (Only if building)
+  if (!options.onlyUpload) {
+    const nextVersion = await handleVersionBump(currentVersion, pubspecPath)
+    if (!nextVersion) return process.exit(0)
+    appMetadata.version = nextVersion
+  }
+
+  // Changelog
+  if (options.desc) {
+    appMetadata.changelog = options.desc
+  } else {
+    const desc = await text({
+      message: 'Update Description (Changelog)',
+      placeholder: 'Fixed bugs...',
+      initialValue: '',
+    })
+    if (isCancel(desc)) return process.exit(0)
+    appMetadata.changelog = desc
+  }
+
+  // 4. Dispatch Modes
+  if (options.onlyBuild) {
+    await runBuildPhase(config, cwd, appMetadata)
+    outro('Build Only Completed.')
+    return
+  }
+
+  if (options.onlyUpload) {
+    await runUploadPhase(config, cwd, appMetadata, options.file)
+    outro('Upload Only Completed.')
+    return
+  }
+
+  // Default: Build + Upload
+  const artifactPaths = await runBuildPhase(config, cwd, appMetadata)
+  // Find artifact for upload?
+  // runBuildPhase returns paths.
+  // Assuming single artifact for now or handle array.
+  // For now, let's assume one platform build or similar.
+  // Or we handle upload platform by platform.
+
+  if (artifactPaths.length > 0) {
+    // TODO: Pass correct file to each uploader?
+    // Simple logic: Upload the file generated.
+    // If Android & iOS both built, we have 2 files.
+    // Uploader needs to know which one.
+    // "AppMetadata" could hold a map? Or we do upload inside build loop?
+    // Better: passing file path to runUploadPhase.
+
+    // Let's refine runUploadPhase to accept specific files if available.
+    // Or runUploadPhase finds them.
+
+    // Actually, Pgyer/Huawei might take APK or IPA.
+    // If we have both, we probably upload both?
+    // Pgyer takes everything. Huawei takes APK. AppStore takes IPA.
+    // I will simplify for Phase 1: Support Android mostly or sequential.
+
+    // If "platform" is filtered, execute accordingly.
+
+    for (const buildRes of artifactPaths) {
+      await runUploadPhase(config, cwd, appMetadata, buildRes.artifactPath)
+    }
+  }
+
+  outro('All operations completed.')
+}
+
+async function handleVersionBump(currentVersion, pubspecPath) {
+  const bumpType = await select({
+    message: `Current Version: ${currentVersion}. Upgrade?`,
+    options: [
+      { value: 'patch', label: 'Patch (x.x.+1)' },
+      { value: 'minor', label: 'Minor (x.+1.0)' },
+      { value: 'major', label: 'Major (+1.0.0)' },
+      { value: 'manual', label: 'Manual Input' },
+      { value: 'skip', label: 'Skip' },
+    ],
+  })
+
+  if (isCancel(bumpType)) return null
+  if (bumpType === 'skip') return currentVersion
+
+  // Logic to increment version... (Simplified for now)
+  // We update pubspec file.
+  // TODO: implement actual semver logic or replace string.
+
+  return currentVersion // Placeholder
+}
+
+async function runBuildPhase(config, cwd, metadata) {
+  const s = spinner()
+  s.start('Building...')
+
+  const results = []
+
+  // Android
+  if (config.build?.android) {
+    const res = await AndroidBuilder.build(config.build.android, cwd)
+    if (res.success) {
+      note(`Android Artifact: ${res.artifactPath}`, 'SUCCESS')
+      results.push(res)
+    } else {
+      s.stop(chalk.red('Android Build Failed'))
+      // Continue or exit?
+    }
+  }
+
+  // iOS
+  if (config.build?.ios) {
+    const res = await IOSBuilder.build(config.build.ios, cwd)
+    if (res.success) {
+      note(`iOS Artifact: ${res.artifactPath}`, 'SUCCESS')
+      results.push(res)
+    }
+  }
+
+  s.stop(`Build Phase Completed. Generated ${results.length} artifacts.`)
+  return results
+}
+
+async function runUploadPhase(config, cwd, metadata, explicitFile) {
+  let file = explicitFile
+  if (!file) {
+    note(`No file provided for upload (Auto-find logic pending)`, 'WARN')
+    return
+  }
+
+  // Create upload manager for parallel uploads
+  const manager = new UploadManager({
+    maxConcurrent: 3,
+    continueOnError: true,
+    verbose: false,
+  })
+
+  const s = spinner()
+  s.start('Uploading to all enabled platforms...')
+
+  try {
+    // Execute parallel uploads
+    const report = await manager.uploadToMultiplePlatforms(file, config, metadata)
+
+    s.stop('Upload phase completed.')
+
+    // Display results
+    if (report.successCount === report.totalUploads) {
+      note(`✅ All platforms uploaded successfully!`, 'SUCCESS')
+    } else if (report.failureCount === report.totalUploads) {
+      note(`❌ Failed to upload to any platform`, 'ERROR')
+    } else {
+      note(`⚠️ Partial success: ${report.successCount}/${report.totalUploads} platforms`, 'WARN')
+    }
+
+    // Ask if user wants to retry failed platforms
+    if (report.failureCount > 0) {
+      const shouldRetry = await confirm({
+        message: `Retry ${report.failureCount} failed platform(s)?`,
+      })
+
+      if (!isCancel(shouldRetry) && shouldRetry) {
+        const retryReport = await manager.retryFailedPlatforms(
+          report.failurePlatforms,
+          file,
+          config,
+          metadata,
+        )
+
+        // Update summary
+        note(
+          `After retry: ${retryReport.successCount}/${retryReport.totalUploads} success`,
+          retryReport.failureCount === 0 ? 'SUCCESS' : 'WARN',
+        )
+      }
+    }
+
+    return report
+  } catch (error) {
+    s.stop(chalk.red('Upload failed'))
+    logger.error(`Upload error: ${error.message}`)
+    throw error
+  }
+}
+
+async function initConfig(path) {
+  const template = `appId: com.example.app
+version: 1.0.0
+
+build:
+  android:
+    type: apk
+    flavor: production
+  ios:
+    scheme: Runner
+    exportMethod: ad-hoc
+
+publish:
+  pgyer:
+    enable: true
+    apiKey: \${PGYER_API_KEY}
+
+  huawei:
+    enable: false
+    appId: ""
+    releaseType: draft
+    auth:
+      clientId: \${HUAWEI_CLIENT_ID}
+      clientSecret: \${HUAWEI_CLIENT_SECRET}
+
+  app_store:
+    enable: false
+    appId: ""
+    auth:
+      # CLI Upload (Required)
+      appleId: \${APPLE_ID}
+      appPassword: \${APPLE_APP_PASSWORD}
+      # API (Optional, for changelog updates)
+      issuerId: ""
+      keyId: ""
+      privateKeyPath: ""
+
+  xiaomi:
+    enable: false
+    auth:
+      appId: \${XIAOMI_APP_ID}
+      appKey: \${XIAOMI_APP_KEY}
+`
+  await fs.writeFile(path, template)
+}

package/lib/commands/vnext-options.js

@@ -0,0 +1,206 @@
+export function buildVNextProjectOptions(options = {}) {
+  const helpers = parseHelpers(options.helpers)
+  const capabilities = {}
+  const examples = parseExamples(options.examples)
+  const composition = parseComposition(options)
+
+  if (options.auth === true) {
+    capabilities.auth = { enabled: true }
+  }
+
+  const serialization = parseSerialization(options)
+  if (serialization) {
+    capabilities.serialization = serialization
+  }
+
+  const result = {}
+  if (Object.keys(capabilities).length > 0) result.capabilities = capabilities
+  if (Object.keys(helpers).length > 0) result.helpers = helpers
+  if (examples.length > 0) result.examples = examples
+  if (composition) result.composition = composition
+  if (composition?.architectureMode) result.architectureMode = composition.architectureMode
+  if (composition?.enableMixinOptions !== undefined) {
+    result.enableMixinOptions = composition.enableMixinOptions
+  }
+
+  const platforms = parseList(options.platforms).map(normalizePlatformName)
+  if (platforms.length > 0) result.platforms = platforms
+
+  const flutterSdk = parseFlutterSdk(options)
+  if (flutterSdk) result.flutterSdk = flutterSdk
+
+  return result
+}
+
+function parseComposition(options) {
+  const rawProfile = normalizeRawCompositionProfile(
+    options.compositionProfile || options.composition,
+  )
+  const profile = normalizeCompositionProfile(rawProfile)
+  const architectureMode = normalizeArchitectureMode(options.architectureMode, profile)
+  const enableMixinOptions = parseEnableMixinOptions(options.enableMixinOptions, rawProfile)
+
+  if (!profile && !architectureMode && enableMixinOptions === undefined) return null
+
+  return {
+    profile: profile || 'base',
+    architectureMode: architectureMode || 'mvvm',
+    ...(enableMixinOptions !== undefined ? { enableMixinOptions } : {}),
+  }
+}
+
+function parseHelpers(value) {
+  const helperNames = parseList(value)
+  const helpers = {}
+
+  for (const helperName of helperNames) {
+    const normalized = normalizeHelperName(helperName)
+    if (normalized) helpers[normalized] = true
+  }
+
+  return helpers
+}
+
+function parseExamples(value) {
+  return parseList(value)
+    .map(normalizeExampleName)
+    .filter(Boolean)
+    .filter((item, index, array) => array.indexOf(item) === index)
+}
+
+function parseSerialization(options) {
+  if (!options.serialization) return null
+
+  const strategy = String(options.serialization).trim()
+  const normalized = strategy.toLowerCase()
+  if (!normalized || ['false', 'off', 'none', 'no'].includes(normalized)) {
+    return { enabled: false, strategy: 'manual', buildRunner: false }
+  }
+
+  return {
+    enabled: true,
+    strategy: normalized,
+    buildRunner:
+      options.serializationBuildRunner === true ||
+      normalized === 'json_serializable' ||
+      normalized === 'freezed',
+  }
+}
+
+function parseFlutterSdk(options) {
+  const mode = options.flutterSdk
+  const version = options.flutterSdkVersion
+  const flutterBin = options.flutterBin
+
+  if (!mode && !version && !flutterBin) return null
+
+  return {
+    mode: mode || (flutterBin ? 'custom' : 'system'),
+    version,
+    flutterBin,
+  }
+}
+
+function parseEnableMixinOptions(value, profile) {
+  if (value === undefined) {
+    return typeof profile === 'string' ? profile.endsWith('mixins') : undefined
+  }
+
+  if (typeof value === 'boolean') return value
+
+  const normalized = String(value).trim().toLowerCase()
+  if (['true', '1', 'yes', 'on', 'enabled'].includes(normalized)) return true
+  if (['false', '0', 'no', 'off', 'disabled'].includes(normalized)) return false
+  return undefined
+}
+
+function parseList(value) {
+  if (!value) return []
+
+  const values = Array.isArray(value) ? value : [value]
+  return values
+    .flatMap((item) => String(item).split(','))
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function normalizeHelperName(value) {
+  const normalized = String(value).trim().toLowerCase().replace(/[-_]/g, '')
+
+  const map = {
+    payment: 'payment',
+    pay: 'payment',
+    webview: 'webview',
+    web: 'webview',
+    permission: 'permission',
+    permissions: 'permission',
+    imagepicker: 'imagePicker',
+    image: 'imagePicker',
+    imagepick: 'imagePicker',
+  }
+
+  return map[normalized]
+}
+
+function normalizePlatformName(value) {
+  const normalized = String(value).trim().toLowerCase()
+  if (normalized === 'harmonyos') return 'harmony'
+  return normalized
+}
+
+function normalizeArchitectureMode(value, profile) {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+  if (normalized === 'native') return 'native'
+  if (normalized === 'mvvm') return 'mvvm'
+  return 'mvvm'
+}
+
+function normalizeRawCompositionProfile(value) {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+  if (['base', 'base_mixins', 'pure_mixins', 'pure'].includes(normalized)) {
+    return normalized
+  }
+  return ''
+}
+
+function normalizeCompositionProfile(value) {
+  return value
+}
+
+function normalizeExampleName(value) {
+  const normalized = String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[-_\s]/g, '')
+
+  const map = {
+    // 默认用户列表入口已属于模板基座；旧 commonListHome 入参只做兼容清理。
+    commonlisthome: null,
+    commonlist: null,
+    listhome: null,
+    networkrequest: 'networkGallery',
+    request: 'networkGallery',
+    networkexamples: 'networkGallery',
+    networkgallery: 'networkGallery',
+    gallery: 'networkGallery',
+    webviewbasic: 'webviewBasic',
+    webview: 'webviewBasic',
+    web: 'webviewBasic',
+    permissionbasic: 'permissionBasic',
+    permission: 'permissionBasic',
+    permissions: 'permissionBasic',
+    imagepickerbasic: 'imagePickerBasic',
+    imagepicker: 'imagePickerBasic',
+    imagepick: 'imagePickerBasic',
+    image: 'imagePickerBasic',
+    paymentshell: 'paymentShell',
+    payment: 'paymentShell',
+    pay: 'paymentShell',
+  }
+
+  return map[normalized]
+}