dshm-compat 0.1.3 → 0.1.5

package/lib/uninstall.js

@@ -0,0 +1,94 @@
+/**
+ * Profile-local uninstall.
+ *
+ * Removes a package from the owning profile: its `node_modules` directory, the
+ * `dependencies` entry, and the `dsh.profile.bundles` entry. The profile
+ * manifest is only changed after the files are moved aside, so a failed delete
+ * can be rolled back.
+ *
+ * @module dshm-compat/uninstall
+ */
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { resolveProfileDir } from './local-install.js'
+
+/** @param {unknown} value */
+function record(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined
+}
+
+/** @param {string} file */
+function readJson(file) {
+  try { return JSON.parse(readFileSync(file, 'utf8').replace(/^\uFEFF/, '')) } catch { return undefined }
+}
+
+/** @param {string} file @param {unknown} value */
+function writeJsonAtomic(file, value) {
+  const temporary = `${file}.tmp-${process.pid}-${Date.now()}`
+  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+  renameSync(temporary, file)
+}
+
+/**
+ * @param {string} name
+ * @param {{ profileDir?: string, env?: NodeJS.ProcessEnv }} [options]
+ */
+export function uninstallLocalPackage(name, options = {}) {
+  const env = options.env ?? process.env
+  if (typeof name !== 'string' || !/^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/i.test(name)) {
+    return { ok: false, error: `invalid package name: ${String(name)}` }
+  }
+  const profileDir = typeof options.profileDir === 'string' && options.profileDir !== ''
+    ? options.profileDir
+    : resolveProfileDir(env)
+  if (profileDir === undefined) return { ok: false, error: 'cannot locate the DSH profile; pass profileDir explicitly' }
+  const manifestPath = join(profileDir, 'package.json')
+  const manifest = record(readJson(manifestPath))
+  if (manifest === undefined) return { ok: false, error: `profile manifest is not an object: ${manifestPath}` }
+
+  const destination = join(profileDir, 'node_modules', ...name.split('/'))
+  const dependencies = record(manifest.dependencies) ?? {}
+  const hadDependency = Object.prototype.hasOwnProperty.call(dependencies, name)
+  const dsh = record(manifest.dsh) ?? {}
+  const profile = record(dsh.profile) ?? {}
+  const bundles = Array.isArray(profile.bundles) ? profile.bundles.filter(item => typeof item === 'string') : []
+  const hadBundle = bundles.includes(name)
+  if (!hadDependency && !hadBundle && !existsSync(destination)) {
+    return { ok: true, name, removed: false, profileDir, restartRequired: false, message: 'not installed in this profile' }
+  }
+
+  const backup = `${destination}.uninstall-${process.pid}-${Date.now()}`
+  const originalManifest = JSON.parse(JSON.stringify(manifest))
+  let moved = false
+  try {
+    if (existsSync(destination)) {
+      renameSync(destination, backup)
+      moved = true
+    }
+    delete dependencies[name]
+    manifest.dependencies = dependencies
+    profile.bundles = bundles.filter(item => item !== name)
+    dsh.profile = profile
+    manifest.dsh = dsh
+    writeJsonAtomic(manifestPath, manifest)
+    if (moved) {
+      try { rmSync(backup, { recursive: true, force: true }) } catch { /* keep the backup if it is locked */ }
+    }
+    return {
+      ok: true,
+      name,
+      removed: true,
+      profileDir,
+      destination,
+      removedDependency: hadDependency,
+      removedBundle: hadBundle,
+      restartRequired: true,
+    }
+  } catch (error) {
+    try { writeJsonAtomic(manifestPath, originalManifest) } catch { /* best effort */ }
+    if (moved && existsSync(backup)) {
+      try { renameSync(backup, destination) } catch { /* best effort */ }
+    }
+    return { ok: false, error: `uninstall failed: ${String(error?.message ?? error)}` }
+  }
+}

package/lib/zip.js

@@ -0,0 +1,59 @@
+/**
+ * Minimal ZIP reader for GitHub release assets.
+ *
+ * Supports stored (0) and deflate (8) entries and the classic EOCD layout.
+ * It intentionally rejects ZIP64 and encrypted archives: release worker
+ * payloads are small, and a missing worker is better than guessing.
+ *
+ * @module dshm-compat/zip
+ */
+import { inflateRawSync } from 'node:zlib'
+
+const EOCD = 0x06054b50
+const CENTRAL = 0x02014b50
+const LOCAL = 0x04034b50
+
+/** @param {Buffer} buffer */
+export function extractZip(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 22) throw new Error('not a ZIP archive')
+  let eocd = -1
+  const start = Math.max(0, buffer.length - 65557)
+  for (let i = buffer.length - 22; i >= start; i--) {
+    if (buffer.readUInt32LE(i) === EOCD) { eocd = i; break }
+  }
+  if (eocd < 0) throw new Error('ZIP end-of-central-directory not found')
+  const count = buffer.readUInt16LE(eocd + 10)
+  const centralOffset = buffer.readUInt32LE(eocd + 16)
+  if (centralOffset === 0xffffffff || count === 0xffff) throw new Error('ZIP64 is not supported')
+
+  /** @type {{ path: string, data: Buffer }[]} */
+  const entries = []
+  let offset = centralOffset
+  for (let index = 0; index < count; index++) {
+    if (offset + 46 > buffer.length || buffer.readUInt32LE(offset) !== CENTRAL) throw new Error('invalid ZIP central directory')
+    const method = buffer.readUInt16LE(offset + 10)
+    const compressedSize = buffer.readUInt32LE(offset + 20)
+    const uncompressedSize = buffer.readUInt32LE(offset + 24)
+    const nameLength = buffer.readUInt16LE(offset + 28)
+    const extraLength = buffer.readUInt16LE(offset + 30)
+    const commentLength = buffer.readUInt16LE(offset + 32)
+    const localOffset = buffer.readUInt32LE(offset + 42)
+    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString('utf8')
+    offset += 46 + nameLength + extraLength + commentLength
+    if (name.endsWith('/')) continue
+    const normalized = name.replace(/\\/g, '/').replace(/^\.\//, '')
+    if (normalized.startsWith('/') || normalized.split('/').includes('..')) throw new Error(`unsafe ZIP path: ${name}`)
+    if (localOffset + 30 > buffer.length || buffer.readUInt32LE(localOffset) !== LOCAL) throw new Error(`invalid ZIP local header: ${name}`)
+    const localNameLength = buffer.readUInt16LE(localOffset + 26)
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28)
+    const dataOffset = localOffset + 30 + localNameLength + localExtraLength
+    const compressed = buffer.subarray(dataOffset, dataOffset + compressedSize)
+    let data
+    if (method === 0) data = compressed
+    else if (method === 8) data = inflateRawSync(compressed)
+    else throw new Error(`unsupported ZIP compression method ${method} for ${name}`)
+    if (data.length !== uncompressedSize) throw new Error(`ZIP size mismatch for ${name}`)
+    entries.push({ path: normalized, data })
+  }
+  return entries
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dshm-compat",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Analyze and convert DSH plugins that cannot be installed or run on HarmonyOS DSHM.",
   "type": "module",
   "main": "index.js",
@@ -24,12 +24,14 @@
     "index.js",
     "bin",
     "lib",
+    "assets",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
     "README.md",
     "INSTALL.md",
     "CHANGELOG.md",
+    "AGENTS.md",
     "docs/*.md"
   ],
   "engines": {

package/lib/recipes/dsh-ops.js

@@ -1,209 +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
-  // DSHM core is a prerelease (e.g. 0.2.1-alpha.4+dshm.56). The upstream
-  // ^0.2.0-rc.2 range does not match 0.2.1-*, and the bundle loader would throw
-  // on the next boot. "workspace:*" follows the running core instead.
-  if (pkg.peerDependencies !== null && typeof pkg.peerDependencies === 'object' && !Array.isArray(pkg.peerDependencies)) {
-    if (typeof pkg.peerDependencies['@deepseek-ai/dsh'] === 'string') {
-      pkg.peerDependencies['@deepseek-ai/dsh'] = 'workspace:*'
-    }
-  }
-  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',
-    'relaxed @deepseek-ai/dsh peer range to workspace:* for the DSHM core',
-    '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 },
-  }
-}