dshm-compat 0.1.2 → 0.1.4

package/lib/recipes/dsh-ops.js

@@ -1,200 +0,0 @@
-/**
- * dsh-ops native recipe.
- *
- * dsh-ops is the first S2 sample: its Rust worker supports Linux, but the
- * published package carries a win32-only runtime and a support matrix that
- * rejects every other target before `DSH_OPS_WORKER_BIN` is consulted. This
- * recipe applies the minimal source patches and stages an externally built
- * `aarch64-unknown-linux-musl` worker. It never builds the worker itself.
- *
- * @module dshm-compat/recipes/dsh-ops
- */
-import { createHash } from 'node:crypto'
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { analyze } from '../analyze.js'
-import { loadArchive, resolveSpec } from '../fetch.js'
-import { packTarGz } from '../pack.js'
-import { compatDir } from '../state.js'
-import { extractTar, findRootPrefix } from '../tar.js'
-import { validateTarball } from '../validate.js'
-
-const BUILD_COMMAND = 'cross build --release --locked --manifest-path native/Cargo.toml --target aarch64-unknown-linux-musl'
-const TARGET = 'aarch64-unknown-linux-musl'
-
-/** @param {import('../tar.js').TarEntry[]} entries */
-function selectRoot(entries) {
-  const candidates = entries
-    .filter(entry => entry.type === 'file' && (entry.path === 'package.json' || entry.path.endsWith('/package.json')))
-    .map(entry => ({ dir: entry.path === 'package.json' ? '' : entry.path.slice(0, -'/package.json'.length), depth: entry.path.split('/').length }))
-    .sort((a, b) => a.depth - b.depth)
-  return candidates.length === 0 ? '' : (candidates[0].dir === '' ? '' : `${candidates[0].dir}/`)
-}
-
-/** @param {Buffer} buffer */
-function isAarch64Elf(buffer) {
-  return buffer.length >= 64
-    && buffer[0] === 0x7f && buffer[1] === 0x45 && buffer[2] === 0x4c && buffer[3] === 0x46
-    && buffer[4] === 2 && buffer[5] === 1
-    && buffer.readUInt16LE(18) === 183
-}
-
-/**
- * @param {string} spec
- * @param {{ report?: any, workerPath?: string, workerBinary?: Buffer, signal?: AbortSignal }} [options]
- */
-export async function convertDshOps(spec, options = {}) {
-  const report = options.report ?? await analyze(spec, { textScan: false, signal: options.signal })
-  const packageName = report.package?.name ?? report.resolved?.name
-  const packageVersion = report.package?.version ?? report.resolved?.version
-  if (packageName !== 'dsh-ops') {
-    return { status: 'not-dsh-ops', message: 'the dsh-ops recipe only accepts the dsh-ops package' }
-  }
-  if (!String(packageVersion ?? '').startsWith('0.3.')) {
-    return { status: 'recipe-mismatch', message: `dsh-ops ${packageVersion} is outside the 0.3.x recipe; inspect the package before patching` }
-  }
-
-  let workerBinary = options.workerBinary
-  if (workerBinary === undefined && typeof options.workerPath === 'string') {
-    try { workerBinary = readFileSync(options.workerPath) } catch (error) {
-      return { status: 'needs-native-build', target: TARGET, command: BUILD_COMMAND, message: `cannot read worker: ${String(error?.message ?? error)}` }
-    }
-  }
-  if (workerBinary === undefined) {
-    return {
-      status: 'needs-native-build',
-      target: TARGET,
-      command: BUILD_COMMAND,
-      message: 'dsh-ops needs a Linux arm64 worker; build it and pass workerPath to compat_convert',
-      notes: [
-        'install a Rust toolchain and a musl aarch64 cross linker, or use cross/cargo-zigbuild',
-        'stage the result at runtime/linux-arm64/dsh-ops-worker',
-      ],
-    }
-  }
-  if (!isAarch64Elf(workerBinary)) {
-    return { status: 'invalid-worker', message: 'worker is not an AArch64 ELF shared/executable image' }
-  }
-
-  const resolved = await resolveSpec(spec, { signal: options.signal })
-  const archive = await loadArchive(resolved, { signal: options.signal })
-  const { entries } = extractTar(archive)
-  const prefix = findRootPrefix(entries)
-  const top = entries
-    .filter(entry => entry.type === 'file')
-    .map(entry => ({ ...entry, path: prefix !== '' && entry.path.startsWith(prefix) ? entry.path.slice(prefix.length) : entry.path }))
-  const root = selectRoot(top)
-  const files = top
-    .filter(entry => entry.path.startsWith(root))
-    .map(entry => ({ ...entry, path: entry.path.slice(root.length) }))
-  const byPath = new Map(files.map(file => [file.path, file]))
-  const getText = path => byPath.get(path)?.data?.toString('utf8')
-
-  const runtime = getText('lib/ptc/runtime.js')
-  if (typeof runtime !== 'string' || !runtime.includes("export const PLATFORMS = Object.freeze(['win32-x64'])")) {
-    return { status: 'recipe-mismatch', message: 'lib/ptc/runtime.js does not match the 0.3.x recipe' }
-  }
-  let patchedRuntime = runtime.replace(
-    "export const PLATFORMS = Object.freeze(['win32-x64'])",
-    "export const PLATFORMS = Object.freeze(['win32-x64', 'linux-arm64'])",
-  )
-  patchedRuntime = patchedRuntime.replaceAll('${platform}-${arch}', 'target')
-  const signature = 'export function resolveWorker(config = {}, { packageRoot = PACKAGE_ROOT, env = process.env, platform = process.platform, arch = process.arch } = {}) {'
-  if (!patchedRuntime.includes(signature)) return { status: 'recipe-mismatch', message: 'resolveWorker signature changed' }
-  patchedRuntime = patchedRuntime.replace(
-    signature,
-    `${signature}\n  const target = platform === 'openharmony' || (platform === 'linux' && arch === 'arm64') ? 'linux-arm64' : \`\${platform}-\${arch}\``,
-  )
-
-  const fileWorker = getText('lib/file/worker.js')
-  if (typeof fileWorker !== 'string' || !fileWorker.includes('const argv = [file]')) {
-    return { status: 'recipe-mismatch', message: 'lib/file/worker.js spawn call changed' }
-  }
-  const patchedFileWorker = fileWorker.replace(
-    'const argv = [file]',
-    "const argv = ['bash', '-c', 'exec \"$0\" \"$@\"', file]",
-  )
-  const ptcWorker = getText('lib/ptc/worker.js')
-  let patchedPtcWorker = ptcWorker
-  if (typeof ptcWorker === 'string' && ptcWorker.includes('let argv = [file]')) {
-    patchedPtcWorker = ptcWorker.replace(
-      'let argv = [file]',
-      "let argv = ['bash', '-c', 'exec \"$0\" \"$@\"', file]",
-    )
-  }
-
-  const pkgFile = byPath.get('package.json')
-  if (pkgFile?.data === undefined) return { status: 'invalid-package', message: 'package.json is missing' }
-  const pkg = JSON.parse(pkgFile.data.toString('utf8'))
-  delete pkg.os
-  delete pkg.cpu
-  if (pkg.optionalDependencies !== null && typeof pkg.optionalDependencies === 'object') {
-    delete pkg.optionalDependencies['@dsh-ops/bash-win32-x64']
-    delete pkg.optionalDependencies['@dsh-ops/pwsh-win32-x64']
-  }
-
-  const pluginFile = byPath.get('dsh-plugin.json')
-  if (pluginFile?.data !== undefined) {
-    const manifest = JSON.parse(pluginFile.data.toString('utf8'))
-    const components = manifest?.contributes?.['x-components']
-    if (Array.isArray(components)) {
-      for (const component of components) {
-        if (component === null || typeof component !== 'object') continue
-        if (Array.isArray(component.platforms) && !component.platforms.includes('openharmony')) component.platforms.push('openharmony')
-        if (Array.isArray(component.targets) && !component.targets.includes('linux-arm64')) component.targets.push('linux-arm64')
-        if (Array.isArray(component.architectures) && !component.architectures.includes('arm64')) component.architectures.push('arm64')
-      }
-    }
-    pluginFile.data = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, 'utf8')
-  }
-
-  const runtimeDir = `runtime/linux-arm64`
-  const workerPath = `${runtimeDir}/dsh-ops-worker`
-  const provenancePath = `${runtimeDir}/provenance.json`
-  const sha256 = createHash('sha256').update(workerBinary).digest('hex')
-  const provenance = {
-    version: typeof pkg.version === 'string' ? pkg.version : '0.0.0',
-    target: 'linux-arm64',
-    executable: 'dsh-ops-worker',
-    sha256,
-    source: 'external aarch64-unknown-linux-musl build supplied by the caller',
-  }
-
-  /** @type {string[]} */
-  const changed = [
-    'added linux-arm64 to PLATFORMS and mapped openharmony/linux-arm64 to it',
-    'wrapped the file worker spawn in bash -c so dshm-vm-bash routes it to the guest',
-    'removed package.json os/cpu gates and win32 optional payloads',
-    'added dsh-plugin.json openharmony/linux-arm64 targets',
-    `staged ${workerPath}`,
-  ]
-  if (patchedPtcWorker !== ptcWorker) changed.push('wrapped the PTC worker spawn in bash -c')
-
-  const output = files.map(file => {
-    if (file.path === 'lib/ptc/runtime.js') return { path: file.path, data: Buffer.from(patchedRuntime, 'utf8'), mode: file.mode }
-    if (file.path === 'lib/file/worker.js') return { path: file.path, data: Buffer.from(patchedFileWorker, 'utf8'), mode: file.mode }
-    if (file.path === 'lib/ptc/worker.js' && patchedPtcWorker !== ptcWorker) return { path: file.path, data: Buffer.from(patchedPtcWorker, 'utf8'), mode: file.mode }
-    if (file.path === 'package.json') return { path: file.path, data: Buffer.from(`${JSON.stringify(pkg, null, 2)}\n`, 'utf8'), mode: file.mode }
-    return { path: file.path, data: file.data, mode: file.mode }
-  })
-  output.push({ path: workerPath, data: workerBinary, mode: 0o755 })
-  output.push({ path: provenancePath, data: Buffer.from(`${JSON.stringify(provenance, null, 2)}\n`, 'utf8'), mode: 0o644 })
-
-  const packed = packTarGz(output)
-  const outputDir = join(compatDir(process.env), 'builds')
-  mkdirSync(outputDir, { recursive: true })
-  const tarball = join(outputDir, `dsh-ops-${pkg.version ?? '0.0.0'}-dshm.tgz`)
-  writeFileSync(tarball, packed)
-  const validation = validateTarball(tarball)
-  if (!validation.ok) return { status: 'invalid-output', tarball, errors: validation.errors }
-  return {
-    status: 'ok',
-    tarball,
-    bytes: packed.length,
-    sha256: createHash('sha256').update(packed).digest('hex'),
-    changed,
-    warnings: validation.warnings,
-    validation,
-    worker: { target: TARGET, sha256 },
-  }
-}