@neuxnet/neux-cli 0.2.3

package/src/core/zip.js

@@ -0,0 +1,120 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { listFiles } from './fs.js'
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, index) => {
+  let value = index
+  for (let bit = 0; bit < 8; bit++) {
+    value = (value & 1) ? (0xedb88320 ^ (value >>> 1)) : (value >>> 1)
+  }
+  return value >>> 0
+})
+
+function crc32(buffer) {
+  let crc = 0xffffffff
+  for (const byte of buffer) {
+    crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8)
+  }
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+function dosDateTime(date = new Date()) {
+  const year = Math.max(date.getFullYear(), 1980)
+  const time = (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2)
+  const day = ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate()
+  return { time, day }
+}
+
+function localHeader(name, data, meta) {
+  const nameBuffer = Buffer.from(name)
+  const header = Buffer.alloc(30)
+  header.writeUInt32LE(0x04034b50, 0)
+  header.writeUInt16LE(20, 4)
+  header.writeUInt16LE(0x0800, 6)
+  header.writeUInt16LE(0, 8)
+  header.writeUInt16LE(meta.time, 10)
+  header.writeUInt16LE(meta.day, 12)
+  header.writeUInt32LE(meta.crc, 14)
+  header.writeUInt32LE(data.length, 18)
+  header.writeUInt32LE(data.length, 22)
+  header.writeUInt16LE(nameBuffer.length, 26)
+  return Buffer.concat([header, nameBuffer])
+}
+
+function centralHeader(name, data, meta, offset) {
+  const nameBuffer = Buffer.from(name)
+  const header = Buffer.alloc(46)
+  header.writeUInt32LE(0x02014b50, 0)
+  header.writeUInt16LE(20, 4)
+  header.writeUInt16LE(20, 6)
+  header.writeUInt16LE(0x0800, 8)
+  header.writeUInt16LE(0, 10)
+  header.writeUInt16LE(meta.time, 12)
+  header.writeUInt16LE(meta.day, 14)
+  header.writeUInt32LE(meta.crc, 16)
+  header.writeUInt32LE(data.length, 20)
+  header.writeUInt32LE(data.length, 24)
+  header.writeUInt16LE(nameBuffer.length, 28)
+  header.writeUInt32LE(offset, 42)
+  return Buffer.concat([header, nameBuffer])
+}
+
+function endOfCentralDirectory(entryCount, centralSize, centralOffset) {
+  const footer = Buffer.alloc(22)
+  footer.writeUInt32LE(0x06054b50, 0)
+  footer.writeUInt16LE(entryCount, 8)
+  footer.writeUInt16LE(entryCount, 10)
+  footer.writeUInt32LE(centralSize, 12)
+  footer.writeUInt32LE(centralOffset, 16)
+  return footer
+}
+
+export async function createZip(sourceDir, outputPath, extraEntries = []) {
+  const sourceRoot = path.resolve(sourceDir)
+  const diskFiles = await listFiles(sourceRoot)
+  const entries = []
+
+  for (const filePath of diskFiles) {
+    entries.push({
+      name: path.relative(sourceRoot, filePath).split(path.sep).join('/'),
+      data: await fs.readFile(filePath),
+    })
+  }
+
+  for (const entry of extraEntries) {
+    entries.push({
+      name: entry.name,
+      data: Buffer.isBuffer(entry.content) ? entry.content : Buffer.from(String(entry.content)),
+    })
+  }
+
+  const localParts = []
+  const centralParts = []
+  let offset = 0
+  const timestamp = dosDateTime()
+
+  for (const entry of entries) {
+    const meta = { ...timestamp, crc: crc32(entry.data) }
+    const local = localHeader(entry.name, entry.data, meta)
+    localParts.push(local, entry.data)
+    centralParts.push(centralHeader(entry.name, entry.data, meta, offset))
+    offset += local.length + entry.data.length
+  }
+
+  const central = Buffer.concat(centralParts)
+  const archive = Buffer.concat([
+    ...localParts,
+    central,
+    endOfCentralDirectory(entries.length, central.length, offset),
+  ])
+
+  await fs.mkdir(path.dirname(outputPath), { recursive: true })
+  await fs.writeFile(outputPath, archive)
+  return {
+    path: outputPath,
+    size: archive.length,
+    sha256: crypto.createHash('sha256').update(archive).digest('hex'),
+    entryCount: entries.length,
+  }
+}

package/src/index.js

@@ -0,0 +1,20 @@
+export { buildProject, buildStyleOnlyProject, buildViewOnlyProject, buildLogicOnlyProject } from './core/compiler.js'
+export { DEFAULT_SERVER_URL, initProject } from './core/init.js'
+export { inspectProject } from './core/project.js'
+export { packProject } from './core/pack.js'
+export { startPreview } from './core/preview-server.js'
+export { startDev } from './core/dev.js'
+export { startWeb } from './core/web.js'
+export { classifyHotUpdate, createHotUpdatePayloads } from './core/web.js'
+export { checkCliUpdate, getCliPackageInfo, getCliVersion, isAutoUpdateEnabled, maybeAutoUpdateCli, updateCli } from './core/update.js'
+export { createProjectWatcher } from './core/watch.js'
+export { createLifecycleEvent, emitLifecycleEvent } from './core/lifecycle.js'
+export { createAppConfig, createDeepLink, createManifest } from './core/manifest.js'
+export { createLocalFileProvider, createUploadProvider, loadUploadProvider, runProviderCommand } from './providers/upload.js'
+export { createServiceProvider } from './providers/service.js'
+export { resolveServiceConfig, resolveServiceConfigDiagnostics, serviceEnvKeys, serviceKeyEnvKey } from './providers/service-config.js'
+export { SERVICE_BASE_PATH, ServiceClient, buildCanonicalString, hmacSha256Base64, md5File, sha256Hex } from './providers/service-client.js'
+export { createDebugPreviewDeepLink, createLocalPreviewDeepLink, createPreviewLaunchParams, createQrPayloadResult } from './core/qr.js'
+export { saveCliKey } from './providers/service-config.js'
+export { renderQrPng, renderTerminalQr } from './core/terminal-qr.js'
+export { DiminaCliError } from './core/errors.js'

package/src/providers/service-client.js

@@ -0,0 +1,149 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { DiminaCliError } from '../core/errors.js'
+
+export const SERVICE_BASE_PATH = '/miniappmgr/openapi/miniapp/cli'
+
+export function buildCanonicalString({ method, requestPath, appId, timestamp, nonce, bodyHash = '' }) {
+  return [
+    String(method).toUpperCase(),
+    requestPath,
+    appId,
+    String(timestamp),
+    nonce,
+    bodyHash,
+  ].join('\n')
+}
+
+export function sha256Hex(value) {
+  return crypto.createHash('sha256').update(value).digest('hex')
+}
+
+export function hmacSha256Base64(key, value) {
+  return crypto.createHmac('sha256', key).update(value).digest('base64')
+}
+
+export async function md5File(filePath) {
+  return crypto.createHash('md5').update(await fs.readFile(filePath)).digest('hex')
+}
+
+function nonce() {
+  return crypto.randomBytes(16).toString('hex')
+}
+
+function serviceUrl(serverUrl, endpoint, query = {}) {
+  const requestPath = `${SERVICE_BASE_PATH}${endpoint}`
+  const url = new URL(requestPath, `${serverUrl.replace(/\/+$/, '')}/`)
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined && value !== null && value !== '') url.searchParams.set(key, String(value))
+  }
+  return { url, requestPath }
+}
+
+function signedHeaders(config, method, requestPath, bodyHash) {
+  const timestamp = Date.now()
+  const requestNonce = nonce()
+  const canonicalString = buildCanonicalString({
+    method,
+    requestPath,
+    appId: config.appId,
+    timestamp,
+    nonce: requestNonce,
+    bodyHash,
+  })
+  return {
+    canonicalString,
+    headers: {
+      'X-App-Id': config.appId,
+      'X-Timestamp': String(timestamp),
+      'X-Nonce': requestNonce,
+      'X-Signature': hmacSha256Base64(config.key, canonicalString),
+    },
+  }
+}
+
+export async function unwrapCommonResponse(response) {
+  const text = await response.text()
+  let data = null
+  if (text) {
+    try {
+      data = JSON.parse(text)
+    }
+    catch {
+      if (!response.ok) {
+        throw new DiminaCliError('NEUX_CLI_HTTP_ERROR', `Service request failed with HTTP ${response.status}`, {
+          httpStatus: response.status,
+          body: text.slice(0, 500),
+        })
+      }
+      throw new DiminaCliError('NEUX_CLI_RESPONSE_INVALID', 'Service response was not valid JSON.', {
+        httpStatus: response.status,
+      })
+    }
+  }
+
+  if (!response.ok) {
+    throw new DiminaCliError('NEUX_CLI_HTTP_ERROR', `Service request failed with HTTP ${response.status}`, {
+      httpStatus: response.status,
+      response: data,
+    })
+  }
+
+  const header = data?.responseHeader
+  if (header && header.status !== 200) {
+    throw new DiminaCliError('NEUX_CLI_SERVICE_ERROR', header.msg || 'Service returned an error.', {
+      serviceStatus: header.status,
+      serviceError: header.error,
+    })
+  }
+  return data && Object.hasOwn(data, 'response') ? data.response : data
+}
+
+export class ServiceClient {
+  constructor(config) {
+    this.config = config
+  }
+
+  async postJson(endpoint, body = {}) {
+    const json = JSON.stringify(body)
+    const { url, requestPath } = serviceUrl(this.config.serverUrl, endpoint)
+    const { headers } = signedHeaders(this.config, 'POST', requestPath, sha256Hex(json))
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        ...headers,
+        'Content-Type': 'application/json',
+      },
+      body: json,
+    })
+    return await unwrapCommonResponse(response)
+  }
+
+  async get(endpoint, query = {}) {
+    const { url, requestPath } = serviceUrl(this.config.serverUrl, endpoint, query)
+    const { headers } = signedHeaders(this.config, 'GET', requestPath, '')
+    const response = await fetch(url, { method: 'GET', headers })
+    return await unwrapCommonResponse(response)
+  }
+
+  async uploadPackage(filePath, fields = {}) {
+    const md5 = await md5File(filePath)
+    const { url, requestPath } = serviceUrl(this.config.serverUrl, '/upload')
+    const { headers } = signedHeaders(this.config, 'POST', requestPath, md5)
+    const bytes = await fs.readFile(filePath)
+    const form = new FormData()
+    form.set('file', new Blob([bytes]), path.basename(filePath))
+    form.set('appId', fields.appId || this.config.appId)
+    form.set('md5', md5)
+    for (const [key, value] of Object.entries(fields)) {
+      if (value !== undefined && value !== null && value !== '') form.set(key, String(value))
+    }
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: form,
+    })
+    return await unwrapCommonResponse(response)
+  }
+}

package/src/providers/service-config.js

@@ -0,0 +1,264 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { DiminaCliError } from '../core/errors.js'
+import { pathExists, readJson, resolvePath } from '../core/fs.js'
+
+const ENV_KEYS = {
+  serverUrl: 'NEUX_CLI_SERVER_URL',
+  appId: 'NEUX_CLI_APP_ID',
+  profile: 'NEUX_CLI_PROFILE',
+  key: 'NEUX_CLI_KEY',
+}
+
+function normalizeEnvSuffix(value) {
+  return String(value || '')
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+}
+
+export function serviceKeyEnvKey(value) {
+  const suffix = normalizeEnvSuffix(value)
+  return suffix ? `${ENV_KEYS.key}_${suffix}` : ''
+}
+
+function keyEnvCandidates({ appId, profile } = {}) {
+  return Array.from(new Set([
+    serviceKeyEnvKey(appId),
+    serviceKeyEnvKey(profile),
+    ENV_KEYS.key,
+  ].filter(Boolean)))
+}
+
+function firstValue(...values) {
+  return values.find(value => value !== undefined && value !== null && value !== '')
+}
+
+function assertNoKey(sourceName, value) {
+  if (!value || typeof value !== 'object') return
+  if (value.key || value.cliKey || value.neuxCliKey) {
+    throw new DiminaCliError('NEUX_CLI_KEY_NOT_ALLOWED', `${sourceName} must not contain a CLI key. Use --key or a NEUX_CLI_KEY_* environment variable.`, {
+      source: sourceName,
+    })
+  }
+}
+
+function resolveKey({ options = {}, appId, profile, userKeys = {} } = {}) {
+  const envKeys = keyEnvCandidates({ appId, profile })
+  if (options.key) return { value: options.key, source: 'cli:--key', envKeys }
+
+  for (const envKey of envKeys) {
+    if (process.env[envKey]) return { value: process.env[envKey], source: `env:${envKey}`, envKeys }
+  }
+
+  const storedKey = userKeys[appId] || (profile ? userKeys[`profile:${profile}`] : '')
+  if (storedKey) return { value: storedKey, source: `user:${appId}`, envKeys }
+
+  return { value: undefined, source: null, envKeys }
+}
+
+function configEnvKeys(resolved = {}, keyEnvKeys = []) {
+  return {
+    serverUrl: ENV_KEYS.serverUrl,
+    appId: ENV_KEYS.appId,
+    profile: ENV_KEYS.profile,
+    key: keyEnvKeys,
+    keyForApp: serviceKeyEnvKey(resolved.appId),
+    keyForProfile: serviceKeyEnvKey(resolved.profile),
+    keyGeneric: ENV_KEYS.key,
+  }
+}
+
+function missingConfigSuggestions(missing, envKeys = {}) {
+  const suggestions = []
+  if (missing.includes('serverUrl')) {
+    suggestions.push(`export ${ENV_KEYS.serverUrl}=https://miniapp.example.com`)
+    suggestions.push('or pass --server-url https://miniapp.example.com')
+  }
+  if (missing.includes('appId')) {
+    suggestions.push(`export ${ENV_KEYS.appId}=<appId>`)
+    suggestions.push('or pass --app-id <appId>')
+  }
+  if (missing.includes('key')) {
+    if (envKeys.keyForApp) suggestions.push(`export ${envKeys.keyForApp}=<key>`)
+    if (envKeys.keyForProfile && envKeys.keyForProfile !== envKeys.keyForApp) {
+      suggestions.push(`export ${envKeys.keyForProfile}=<key>`)
+    }
+    suggestions.push(`export ${ENV_KEYS.key}=<key>`)
+    suggestions.push('or pass --key <key>')
+  }
+  return suggestions
+}
+
+async function readOptionalJson(filePath) {
+  if (!(await pathExists(filePath))) return null
+  return await readJson(filePath)
+}
+
+async function readProjectServiceConfig(projectPath) {
+  const neuxConfigPath = path.join(projectPath, 'neux.config.json')
+  const neuxConfig = await readOptionalJson(neuxConfigPath)
+  if (neuxConfig) {
+    assertNoKey(neuxConfigPath, neuxConfig)
+    return {
+      appId: neuxConfig.appId || neuxConfig.appid,
+      profile: neuxConfig.profile,
+      serverUrl: neuxConfig.serverUrl,
+      source: neuxConfigPath,
+    }
+  }
+
+  const projectConfigPath = path.join(projectPath, 'project.config.json')
+  const projectPrivateConfigPath = path.join(projectPath, 'project.private.config.json')
+  const projectConfig = await readOptionalJson(projectConfigPath)
+  const projectPrivateConfig = await readOptionalJson(projectPrivateConfigPath)
+  const effectiveProjectConfig = mergeProjectConfig(projectConfig || {}, projectPrivateConfig || {})
+  const nested = {
+    ...(effectiveProjectConfig.neux || {}),
+    ...(effectiveProjectConfig.neuxCli || {}),
+  }
+  assertNoKey(projectConfigPath, projectConfig?.neuxCli || projectConfig?.neux || {})
+  assertNoKey(projectPrivateConfigPath, projectPrivateConfig?.neuxCli || projectPrivateConfig?.neux || {})
+  return {
+    appId: nested.appId || nested.appid || effectiveProjectConfig.appId || effectiveProjectConfig.appid,
+    profile: nested.profile,
+    serverUrl: nested.serverUrl || effectiveProjectConfig.serverUrl,
+    source: projectPrivateConfig ? projectPrivateConfigPath : projectConfig ? projectConfigPath : null,
+  }
+}
+
+function mergeProjectConfig(projectConfig = {}, privateConfig = {}) {
+  return {
+    ...projectConfig,
+    ...privateConfig,
+    neux: {
+      ...(projectConfig.neux || {}),
+      ...(privateConfig.neux || {}),
+    },
+    neuxCli: {
+      ...(projectConfig.neuxCli || {}),
+      ...(privateConfig.neuxCli || {}),
+    },
+  }
+}
+
+async function readUserProfileConfig(options = {}) {
+  const configPath = resolvePath(
+    options.config || options.configPath || process.env.NEUX_CLI_CONFIG,
+    path.join(os.homedir(), '.neux', 'config.json'),
+  )
+  const config = await readOptionalJson(configPath)
+  if (!config) return { configPath, profiles: {}, keys: {}, raw: {} }
+
+  assertNoKey(configPath, config)
+  for (const [profileName, profile] of Object.entries(config.profiles || {})) {
+    assertNoKey(`${configPath} profile ${profileName}`, profile)
+  }
+  return { configPath, profiles: config.profiles || {}, keys: config.keys || {}, raw: config }
+}
+
+export async function saveCliKey({ appId, key, configPath } = {}) {
+  const normalizedAppId = String(appId || '').trim()
+  const normalizedKey = String(key || '').trim()
+  if (!normalizedAppId || !normalizedKey) {
+    throw new DiminaCliError('NEUX_CLI_KEY_INVALID', 'App ID and CLI Key are required.')
+  }
+  const userConfig = await readUserProfileConfig({ configPath })
+  const nextConfig = {
+    ...userConfig.raw,
+    profiles: userConfig.profiles,
+    keys: {
+      ...userConfig.keys,
+      [normalizedAppId]: normalizedKey,
+    },
+  }
+  await fs.mkdir(path.dirname(userConfig.configPath), { recursive: true })
+  await fs.writeFile(userConfig.configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, { mode: 0o600 })
+  await fs.chmod(userConfig.configPath, 0o600)
+  return { configPath: userConfig.configPath, appId: normalizedAppId }
+}
+
+function normalizeConfig(config) {
+  const normalized = { ...config }
+  if (normalized.serverUrl) normalized.serverUrl = String(normalized.serverUrl).replace(/\/+$/, '')
+  return normalized
+}
+
+export async function resolveServiceConfig(options = {}, requirements = {}) {
+  const { resolved, envKeys } = await resolveServiceConfigSnapshot(options)
+  const missing = []
+  for (const field of requirements.required || ['serverUrl', 'appId', 'key']) {
+    if (!resolved[field]) missing.push(field)
+  }
+  if (missing.length > 0) {
+    throw new DiminaCliError('NEUX_CLI_CONFIG_MISSING', `Missing service configuration: ${missing.join(', ')}`, {
+      missing,
+      appId: resolved.appId,
+      profile: resolved.profile,
+      envKeys,
+      suggestions: missingConfigSuggestions(missing, envKeys),
+    })
+  }
+
+  return resolved
+}
+
+export async function resolveServiceConfigDiagnostics(options = {}) {
+  const { resolved, envKeys } = await resolveServiceConfigSnapshot(options)
+  const missing = []
+  for (const field of ['serverUrl', 'appId', 'key']) {
+    if (!resolved[field]) missing.push(field)
+  }
+
+  return {
+    ok: missing.length === 0,
+    command: 'config doctor',
+    projectPath: resolved.projectPath,
+    profile: resolved.profile,
+    serverUrl: resolved.serverUrl,
+    appId: resolved.appId,
+    missing,
+    sources: {
+      project: resolved.sources.project,
+      user: resolved.sources.user,
+      key: resolved.sources.key,
+    },
+    key: {
+      present: !!resolved.key,
+      source: resolved.sources.key,
+      candidates: envKeys.key,
+    },
+    envKeys,
+    suggestions: missingConfigSuggestions(missing, envKeys),
+  }
+}
+
+async function resolveServiceConfigSnapshot(options = {}) {
+  const projectPath = resolvePath(options.project)
+  const project = await readProjectServiceConfig(projectPath)
+  const profileName = firstValue(options.profile, process.env[ENV_KEYS.profile], project.profile)
+  const userConfig = await readUserProfileConfig(options)
+  const profile = profileName ? userConfig.profiles[profileName] || {} : {}
+  const appId = firstValue(options.appId, options.app_id, process.env[ENV_KEYS.appId], project.appId)
+  const key = resolveKey({ options, appId, profile: profileName, userKeys: userConfig.keys })
+  const resolved = normalizeConfig({
+    projectPath,
+    profile: profileName,
+    serverUrl: firstValue(options.serverUrl, options.server_url, process.env[ENV_KEYS.serverUrl], project.serverUrl, profile.serverUrl),
+    appId,
+    key: key.value,
+    sources: {
+      project: project.source,
+      user: userConfig.configPath,
+      key: key.source,
+    },
+  })
+  return {
+    resolved,
+    envKeys: configEnvKeys(resolved, key.envKeys),
+  }
+}
+
+export const serviceEnvKeys = { ...ENV_KEYS }

package/src/providers/service.js

@@ -0,0 +1,146 @@
+import { createDebugPreviewDeepLink, createPreviewLaunchParams, createQrPayloadResult } from '../core/qr.js'
+import { DiminaCliError } from '../core/errors.js'
+import { getServiceClientVersion } from '../core/package-info.js'
+import { resolveServiceConfig } from './service-config.js'
+import { ServiceClient } from './service-client.js'
+
+function normalizeBoolean(value) {
+  return value === true || value === 'true'
+}
+
+function versionFields(options = {}) {
+  return {
+    versionId: options.versionId || options.version_id,
+    versionNumber: options.versionNumber || options.version_number || options.version,
+  }
+}
+
+async function createClient(options, required) {
+  const config = await resolveServiceConfig(options, { required })
+  return {
+    config,
+    client: new ServiceClient(config),
+  }
+}
+
+async function uploadFields(config, options = {}, extra = {}) {
+  const changelog = options.changelog || options.appChangelog || options.app_changelog || options.desc || options.description
+  const launchParams = createPreviewLaunchParams(options)
+  return {
+    appId: config.appId,
+    desc: options.desc || options.description || changelog,
+    changelog,
+    clientVersion: await getServiceClientVersion(),
+    versionNumber: options.versionNumber || options.version_number || options.version,
+    preview: normalizeBoolean(options.preview),
+    submitAudit: normalizeBoolean(options.submitAudit || options.submit_audit),
+    debugPreview: false,
+    channel: options.channel,
+    proxy: options.proxy,
+    needUploadSourcemap: normalizeBoolean(options.needUploadSourcemap || options.need_upload_sourcemap || options.sourcemap) || undefined,
+    ...launchParams,
+    ...extra,
+  }
+}
+
+async function previewFields(config, options = {}) {
+  return {
+    appId: config.appId,
+    ...versionFields(options),
+    clientVersion: await getServiceClientVersion(),
+    channel: options.channel,
+    ...createPreviewLaunchParams(options),
+  }
+}
+
+function withVersion(payload, version) {
+  if (!payload || version === undefined || version === null || version === '') return payload
+  const url = new URL(payload)
+  if (!url.searchParams.has('version')) url.searchParams.set('version', String(version))
+  return url.toString()
+}
+
+function withTrialQr(response, version) {
+  const payload = withVersion(response?.preview?.scanUrl || response?.scanUrl, version)
+  return payload ? { ...response, ...createQrPayloadResult(payload) } : response
+}
+
+export function createServiceProvider() {
+  const provider = {
+    login: async () => {
+      throw new DiminaCliError('DIMINA_PROVIDER_UNSUPPORTED', 'login is not implemented for the signed service provider.', {
+        command: 'login',
+      })
+    },
+
+    upload: async ({ artifact, options }) => {
+      const { config, client } = await createClient(options)
+      const fields = await uploadFields(config, options)
+      const response = await client.uploadPackage(artifact.packagePath, fields)
+      return withTrialQr(response, artifact.config?.versionName)
+    },
+
+    debugPreview: async ({ artifact, options }) => {
+      if (normalizeBoolean(options.preview) || normalizeBoolean(options.submitAudit || options.submit_audit)) {
+        throw new DiminaCliError('NEUX_CLI_DEBUG_PREVIEW_FLAGS_INVALID', 'debug-preview cannot be combined with preview or submit-audit.', {
+          preview: normalizeBoolean(options.preview),
+          submitAudit: normalizeBoolean(options.submitAudit || options.submit_audit),
+        })
+      }
+
+      const { config, client } = await createClient(options)
+      const response = await client.uploadPackage(artifact.packagePath, await uploadFields(config, options, {
+        preview: false,
+        submitAudit: false,
+        debugPreview: true,
+      }))
+      const deepLink = createDebugPreviewDeepLink({
+        appId: config.appId,
+        name: artifact.config?.name,
+        version: artifact.config?.versionName,
+        download: response.packageDownloadUrl,
+        ...createPreviewLaunchParams(options),
+      })
+      return {
+        ...response,
+        ...createQrPayloadResult(deepLink),
+      }
+    },
+
+    servicePreview: async ({ options }) => {
+      const { config, client } = await createClient(options)
+      return withTrialQr(await client.postJson('/preview', await previewFields(config, options)))
+    },
+
+    submitAudit: async ({ options }) => {
+      const { config, client } = await createClient(options)
+      return await client.postJson('/submit-audit', {
+        appId: config.appId,
+        ...versionFields(options),
+        channel: options.channel,
+        host: options.host,
+        autoPublish: normalizeBoolean(options.autoPublish || options.auto_publish) || undefined,
+      })
+    },
+
+    version: async ({ options }) => {
+      const { config, client } = await createClient(options, ['serverUrl', 'appId', 'key'])
+      return await client.get('/version', { appId: config.appId })
+    },
+
+    auditStatus: async ({ options }) => {
+      const { config, client } = await createClient(options)
+      const versionId = options.versionId || options.version_id
+      if (!versionId) {
+        throw new DiminaCliError('NEUX_CLI_CONFIG_MISSING', 'Missing required option: versionId', {
+          missing: ['versionId'],
+        })
+      }
+      return await client.get('/audit-status', { appId: config.appId, versionId })
+    },
+  }
+
+  provider.audit = provider.submitAudit
+  provider.submit = provider.submitAudit
+  return provider
+}