@neuxnet/neux-cli 0.2.3

package/src/core/lifecycle.js

@@ -0,0 +1,32 @@
+export function createLifecycleEvent(event, payload = {}) {
+  return {
+    event,
+    timestamp: Date.now(),
+    ...jsonSafe(payload),
+  }
+}
+
+export async function emitLifecycleEvent(options, event, payload = {}) {
+  const record = createLifecycleEvent(event, payload)
+  await options.onEvent?.(record)
+  return record
+}
+
+function jsonSafe(value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      code: value.code,
+    }
+  }
+  if (Array.isArray(value)) return value.map(jsonSafe)
+  if (!value || typeof value !== 'object') return value
+
+  const output = {}
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === 'function') continue
+    output[key] = jsonSafe(item)
+  }
+  return output
+}

package/src/core/manifest.js

@@ -0,0 +1,72 @@
+export function createManifest(config, packageUrl, packageSha256, allowDowngrade = false) {
+  return {
+    schemaVersion: 2,
+    appId: config.appId,
+    name: config.name,
+    description: config.description || '',
+    versionCode: config.versionCode,
+    versionName: config.versionName,
+    path: config.path,
+    entryPath: config.path,
+    packageUrl,
+    sha256: packageSha256,
+    allowDowngrade,
+    address: {
+      id: config.appId,
+      manifestUrl: '',
+      version: config.versionCode,
+      path: config.path,
+    },
+    appInfo: {
+      description: config.description || '',
+      categories: config.categories || [],
+      icons: Object.values(config.icons || {}).filter(Boolean),
+      screenshots: config.screenshots || [],
+    },
+    signature: '',
+    algorithm: '',
+    publicKeyId: '',
+    offlineEnabled: true,
+    updateMode: 'manual',
+    minRuntimeVersion: '',
+    permissions: [],
+    domains: [],
+  }
+}
+
+export function createDeepLink({ appId, version, appPath, query = '', fragment = '' }) {
+  const encodedPath = String(appPath || '')
+    .split('/')
+    .filter(Boolean)
+    .map(segment => encodeURIComponent(segment))
+    .join('/')
+  const pathSegment = encodedPath ? `/${encodedPath}` : ''
+  const versionSegment = Number.isInteger(version) ? `;version=${version}` : ''
+  const querySegment = query ? `?${query}` : ''
+  const fragmentSegment = fragment ? `#${fragment}` : ''
+  return `dimina://miniapp/${encodeURIComponent(appId)}${versionSegment}${pathSegment}${querySegment}${fragmentSegment}`
+}
+
+export function createAppConfig({
+  appId,
+  appName,
+  appPath,
+  description = '',
+  versionCode = 1,
+  versionName = '1.0.0',
+  categories = [],
+  icons = {},
+  screenshots = [],
+}) {
+  return {
+    appId,
+    name: appName || `App ${appId}`,
+    path: appPath || 'pages/index',
+    description,
+    categories,
+    icons,
+    screenshots,
+    versionCode,
+    versionName,
+  }
+}

package/src/core/pack.js

@@ -0,0 +1,156 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { buildProject } from './compiler.js'
+import { pathExists, readJson, resolvePath, writeJson } from './fs.js'
+import { createAppConfig, createDeepLink, createManifest } from './manifest.js'
+import { inspectProject } from './project.js'
+import { createZip } from './zip.js'
+import { defaultOut } from './defaults.js'
+
+export async function packProject(options = {}) {
+  const projectInfo = await inspectProject(options)
+  const out = resolvePath(options.out || options.output || defaultOut(options.command || 'pack'))
+  let packageSourceDir = resolvePath(options.sourceDir || options.compiledDir || projectInfo.sourceRoot)
+  let buildResult = null
+  const packageExtension = String(options.packageExtension || 'zip').replace(/^\./, '')
+  const isWgtPackage = packageExtension === 'wgt'
+  const temporaryPaths = []
+
+  if (options.build) {
+    const buildOut = resolvePath(options.buildOut || (isWgtPackage ? path.join(out, '..', '.wgt-build') : path.join(out, '.build')))
+    buildResult = await buildProject({ ...options, out: buildOut })
+    packageSourceDir = await resolveBuiltAppDir(buildOut, projectInfo.appId, buildResult)
+    if (isWgtPackage && !options.buildOut) temporaryPaths.push(buildOut)
+  }
+
+  const appId = options.appId || projectInfo.appId
+  const compilerConfig = buildResult?.compilerResult && typeof buildResult.compilerResult === 'object'
+    ? buildResult.compilerResult
+    : {}
+  const cliConfig = projectInfo.cliConfig || {}
+  const appOutDir = isWgtPackage ? out : path.join(out, appId)
+  const config = createAppConfig({
+    appId,
+    appName: options.name || compilerConfig.name || projectInfo.name,
+    appPath: options.entryPath || compilerConfig.path || compilerConfig.entryPath || projectInfo.entryPath,
+    description: options.description || '',
+    versionCode: Number.parseInt(firstConfigValue(options.versionCode, cliConfig.versionCode, 1), 10),
+    versionName: firstConfigValue(
+      options.versionName,
+      options.version,
+      cliConfig.versionName,
+      cliConfig.version,
+      await readPackageVersion(projectInfo.projectPath),
+      '1.0.0',
+    ),
+  })
+
+  if (isWgtPackage && (options.command === 'build' || options.command === 'wgt')) {
+    await fs.rm(appOutDir, { recursive: true, force: true })
+  }
+  await fs.mkdir(appOutDir, { recursive: true })
+  if (isWgtPackage) {
+    const stagingDir = path.join(out, `.wgt-${appId}`)
+    temporaryPaths.push(stagingDir)
+    try {
+      await fs.rm(stagingDir, { recursive: true, force: true })
+      await fs.mkdir(stagingDir, { recursive: true })
+
+      const configPath = path.join(stagingDir, 'config.json')
+      await writeJson(configPath, config)
+      const innerPackagePath = path.join(stagingDir, `${appId}.zip`)
+      const innerZipInfo = await createZip(packageSourceDir, innerPackagePath)
+
+      const packagePath = path.join(appOutDir, `${appId}.wgt`)
+      const zipInfo = await createZip(stagingDir, packagePath)
+
+      return {
+        ok: true,
+        command: options.command || 'pack',
+        projectPath: projectInfo.projectPath,
+        sourceDir: packageSourceDir,
+        outputDir: appOutDir,
+        appId,
+        config,
+        configPath: null,
+        packagePath,
+        manifestPath: null,
+        sha256: zipInfo.sha256,
+        packageSize: zipInfo.size,
+        innerPackageName: `${appId}.zip`,
+        innerSha256: innerZipInfo.sha256,
+        innerPackageSize: innerZipInfo.size,
+        buildResult,
+      }
+    }
+    finally {
+      for (const temporaryPath of temporaryPaths.reverse()) {
+        await fs.rm(temporaryPath, { recursive: true, force: true })
+      }
+    }
+  }
+
+  const configPath = path.join(appOutDir, 'config.json')
+  await writeJson(configPath, config)
+
+  const zipPath = path.join(appOutDir, `${appId}.${packageExtension}`)
+  const configContent = `${JSON.stringify(config, null, 2)}\n`
+  const zipInfo = await createZip(packageSourceDir, zipPath, [{ name: 'config.json', content: configContent }])
+  const manifest = createManifest(config, `${appId}.${packageExtension}`, zipInfo.sha256, !!options.allowDowngrade)
+  const manifestPath = path.join(appOutDir, 'manifest.json')
+  await writeJson(manifestPath, manifest)
+
+  return {
+    ok: true,
+    command: 'pack',
+    projectPath: projectInfo.projectPath,
+    sourceDir: packageSourceDir,
+    outputDir: appOutDir,
+    appId,
+    config,
+    configPath,
+    packagePath: zipPath,
+    manifestPath,
+    sha256: zipInfo.sha256,
+    packageSize: zipInfo.size,
+    buildResult,
+  }
+}
+
+async function readPackageVersion(projectPath) {
+  const packageJson = await readJson(path.join(projectPath, 'package.json'), {})
+  return packageJson?.version
+}
+
+function firstConfigValue(...values) {
+  return values.find(value => value !== undefined && value !== null && value !== '')
+}
+
+async function resolveBuiltAppDir(buildOut, appId, buildResult) {
+  const compilerResult = buildResult?.compilerResult && typeof buildResult.compilerResult === 'object'
+    ? buildResult.compilerResult
+    : {}
+  const candidates = Array.from(new Set([
+    appId,
+    compilerResult.appId,
+    buildResult?.appId,
+  ].filter(Boolean)))
+
+  for (const candidate of candidates) {
+    const candidatePath = path.join(buildOut, candidate)
+    if (await pathExists(candidatePath)) return candidatePath
+  }
+
+  return path.join(buildOut, appId)
+}
+
+export function createPreviewUrls({ serverUrl, appId, versionCode, appPath, packageExtension = 'zip' }) {
+  const base = `${serverUrl}/${encodeURIComponent(appId)}`
+  const extension = String(packageExtension).replace(/^\./, '')
+  return {
+    serverUrl,
+    manifestUrl: `${base}/manifest.json`,
+    packageUrl: `${base}/${encodeURIComponent(appId)}.${extension}`,
+    deepLink: createDeepLink({ appId, version: versionCode, appPath }),
+  }
+}

package/src/core/package-info.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { brand } from './brand.js'
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+let packageInfoPromise
+
+export async function getCliPackageInfo() {
+  packageInfoPromise ||= fs.readFile(path.join(packageRoot, 'package.json'), 'utf8')
+    .then(JSON.parse)
+
+  const packageJson = await packageInfoPromise
+  return {
+    packageName: packageJson.name || brand.packageName,
+    version: packageJson.version,
+    packageRoot,
+  }
+}
+
+export async function getCliVersion() {
+  return (await getCliPackageInfo()).version
+}
+
+export async function getServiceClientVersion() {
+  return `${brand.serviceClientName}/${await getCliVersion()}`
+}

package/src/core/preview-server.js

@@ -0,0 +1,123 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import os from 'node:os'
+import path from 'node:path'
+import { DiminaCliError } from './errors.js'
+import { emitLifecycleEvent } from './lifecycle.js'
+import { packProject, createPreviewUrls } from './pack.js'
+import { createLocalPreviewDeepLink, createQrPayloadResult } from './qr.js'
+
+export function getLocalIPAddress() {
+  for (const addresses of Object.values(os.networkInterfaces())) {
+    for (const address of addresses || []) {
+      if (address.family === 'IPv4' && !address.internal) return address.address
+    }
+  }
+  return '127.0.0.1'
+}
+
+function contentType(filePath) {
+  const ext = path.extname(filePath)
+  if (ext === '.json') return 'application/json; charset=utf-8'
+  if (ext === '.zip') return 'application/zip'
+  if (ext === '.png') return 'image/png'
+  return 'application/octet-stream'
+}
+
+export async function startStaticServer(rootDir, host, port) {
+  const root = path.resolve(rootDir)
+  const server = http.createServer((req, res) => {
+    let pathname
+    try {
+      pathname = decodeURIComponent(new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`).pathname)
+    }
+    catch {
+      res.writeHead(400)
+      res.end('Bad request')
+      return
+    }
+
+    const resolved = path.resolve(path.join(root, path.normalize(pathname)))
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+      res.writeHead(403)
+      res.end('Forbidden')
+      return
+    }
+
+    fs.stat(resolved, (statError, stat) => {
+      if (statError || !stat.isFile()) {
+        res.writeHead(404)
+        res.end('Not found')
+        return
+      }
+      res.writeHead(200, { 'Content-Type': contentType(resolved) })
+      fs.createReadStream(resolved).pipe(res)
+    })
+  })
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(port, host, () => {
+      server.off('error', reject)
+      resolve()
+    })
+  }).catch((error) => {
+    throw new DiminaCliError('DIMINA_PREVIEW_SERVER_FAILED', `Failed to start preview server: ${error.message}`, {
+      host,
+      port,
+      cause: error.code,
+    })
+  })
+
+  return server
+}
+
+export async function startPreview(options = {}) {
+  const command = options.command || 'preview'
+  const host = options.host || getLocalIPAddress()
+  const port = Number.parseInt(options.port ?? 5273, 10)
+  const runPack = options.withPackOutputRedirect || (action => action())
+  const pack = await runPack(() => packProject({ ...options, command }))
+  const wgtPack = await runPack(() => packProject({
+    ...options,
+    command,
+    out: pack.outputDir,
+    packageExtension: 'wgt',
+  }))
+  const server = await startStaticServer(path.dirname(pack.outputDir), host, port)
+  const address = server.address()
+  const resolvedPort = typeof address === 'object' && address ? address.port : port
+  const serverUrl = `http://${host}:${resolvedPort}`
+  const urls = createPreviewUrls({
+    serverUrl,
+    appId: pack.appId,
+    versionCode: wgtPack.config.versionCode,
+    appPath: pack.config.path,
+    packageExtension: 'wgt',
+  })
+  const deepLink = createLocalPreviewDeepLink({
+    appId: pack.appId,
+    download: urls.packageUrl,
+    version: wgtPack.config.versionCode,
+    pagePath: pack.config.path,
+  })
+
+  const session = {
+    ok: true,
+    command,
+    ...urls,
+    ...createQrPayloadResult(deepLink),
+    appId: pack.appId,
+    artifact: pack,
+    close: async () => {
+      await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()))
+      await emitLifecycleEvent(options, 'close', {
+        command,
+        appId: pack.appId,
+        serverUrl,
+      })
+    },
+  }
+  await emitLifecycleEvent(options, 'ready', session)
+  return session
+}

package/src/core/project.js

@@ -0,0 +1,101 @@
+import path from 'node:path'
+import { DiminaCliError } from './errors.js'
+import { pathExists, readJson, resolvePath } from './fs.js'
+
+export async function inspectProject(options = {}) {
+  const projectPath = resolvePath(options.project)
+  const projectConfigPath = path.join(projectPath, 'project.config.json')
+  const projectPrivateConfigPath = path.join(projectPath, 'project.private.config.json')
+
+  if (!(await pathExists(projectConfigPath))) {
+    throw new DiminaCliError('DIMINA_PROJECT_CONFIG_NOT_FOUND', `project.config.json not found: ${projectConfigPath}`, {
+      projectPath,
+      projectConfigPath,
+    })
+  }
+
+  const projectConfig = await readJson(projectConfigPath)
+  const projectPrivateConfig = await readJson(projectPrivateConfigPath, {})
+  const effectiveProjectConfig = mergeProjectConfig(projectConfig, projectPrivateConfig)
+  const cliConfig = await readProjectCliConfig(projectPath, effectiveProjectConfig)
+  const miniprogramRoot = effectiveProjectConfig.miniprogramRoot || ''
+  const sourceRoot = path.resolve(projectPath, miniprogramRoot)
+  const appConfigPath = path.join(sourceRoot, 'app.json')
+  const appConfig = await readJson(appConfigPath, {})
+  const pages = Array.isArray(appConfig.pages) ? appConfig.pages : []
+  const appId = options.appId || effectiveProjectConfig.appid || effectiveProjectConfig.appId || ''
+  const appName = options.name || effectiveProjectConfig.projectname || effectiveProjectConfig.projectName || `App ${appId || 'unknown'}`
+  const entryPath = options.entryPath || appConfig.entryPagePath || pages[0] || 'pages/index'
+  const hasPrivateConfig = await pathExists(projectPrivateConfigPath)
+
+  return {
+    ok: true,
+    command: 'inspect',
+    projectPath,
+    sourceRoot,
+    projectConfigPath,
+    projectPrivateConfigPath: hasPrivateConfig ? projectPrivateConfigPath : null,
+    appConfigPath,
+    appId,
+    name: appName,
+    entryPath,
+    pages,
+    compileType: effectiveProjectConfig.compileType || 'miniprogram',
+    libVersion: effectiveProjectConfig.libVersion || '',
+    miniprogramRoot,
+    setting: effectiveProjectConfig.setting || {},
+    packOptions: normalizePackOptions(effectiveProjectConfig.packOptions),
+    condition: effectiveProjectConfig.condition || {},
+    neuxCli: effectiveProjectConfig.neuxCli || {},
+    cliConfig,
+  }
+}
+
+function mergeProjectConfig(projectConfig = {}, privateConfig = {}) {
+  return {
+    ...projectConfig,
+    ...privateConfig,
+    setting: {
+      ...(projectConfig.setting || {}),
+      ...(privateConfig.setting || {}),
+    },
+    packOptions: {
+      ...(projectConfig.packOptions || {}),
+      ...(privateConfig.packOptions || {}),
+    },
+    neux: {
+      ...(projectConfig.neux || {}),
+      ...(privateConfig.neux || {}),
+    },
+    neuxCli: {
+      ...(projectConfig.neuxCli || {}),
+      ...(privateConfig.neuxCli || {}),
+    },
+  }
+}
+
+function normalizePackOptions(packOptions = {}) {
+  return {
+    ignore: Array.isArray(packOptions.ignore) ? packOptions.ignore : [],
+    include: Array.isArray(packOptions.include) ? packOptions.include : [],
+  }
+}
+
+async function readProjectCliConfig(projectPath, projectConfig) {
+  const neuxConfigPath = path.join(projectPath, 'neux.config.json')
+  const neuxConfig = await readJson(neuxConfigPath, {})
+  const source = {
+    ...pickCliConfig(projectConfig),
+    ...neuxConfig,
+  }
+
+  return pickCliConfig(source)
+}
+
+function pickCliConfig(source = {}) {
+  return {
+    version: source.version,
+    versionName: source.versionName,
+    versionCode: source.versionCode,
+  }
+}

package/src/core/prompts.js

@@ -0,0 +1,71 @@
+import readline from 'node:readline/promises'
+import process from 'node:process'
+
+export function shouldPrompt(options = {}) {
+  return options.interactive !== false
+    && options.noInteractive !== true
+    && !options.json
+    && !!process.stdin.isTTY
+    && !!process.stdout.isTTY
+}
+
+export async function promptLine(label, options = {}) {
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    if (options.secret) return await promptSecret(terminal, label)
+    return await terminal.question(label)
+  }
+  finally {
+    terminal.close()
+  }
+}
+
+export async function promptLines(prompts) {
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const values = {}
+    for (const prompt of prompts) {
+      values[prompt.name] = prompt.secret
+        ? await promptSecret(terminal, prompt.label)
+        : await terminal.question(prompt.label)
+    }
+    return values
+  }
+  finally {
+    terminal.close()
+  }
+}
+
+async function promptSecret(terminal, label) {
+  if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== 'function') {
+    return await terminal.question(label)
+  }
+
+  process.stdout.write(label)
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+  return await new Promise(resolve => {
+    let value = ''
+    const onData = chunk => {
+      const character = String(chunk)
+      if (character === '\u0003') {
+        process.stdin.setRawMode(false)
+        process.exit(130)
+      }
+      if (character === '\r' || character === '\n') {
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        process.stdin.off('data', onData)
+        process.stdout.write('\n')
+        resolve(value)
+      }
+      else if (character === '\u007f' || character === '\b') {
+        value = value.slice(0, -1)
+      }
+      else if (character >= ' ') {
+        value += character
+      }
+    }
+    process.stdin.on('data', onData)
+  })
+}