cross-packer 0.1.0

package/src/archive/ar.ts

@@ -0,0 +1,41 @@
+import { Buffer } from 'node:buffer'
+
+export interface ArEntry {
+  name: string
+  content: Buffer
+  mode?: number
+  mtime?: number
+}
+
+/**
+ * Minimal `ar` archive writer, sufficient for .deb assembly
+ * (debian-binary + control.tar.xz + data.tar.xz).
+ */
+export function createArArchive(files: ArEntry[]): Buffer {
+  const parts = [Buffer.from('!<arch>\n')]
+
+  for (const file of files) {
+    const mtime = file.mtime ?? Math.floor(Date.now() / 1000)
+    const mode = file.mode ?? 0o100644
+    const size = file.content.length
+
+    const header = Buffer.alloc(60)
+    header.write(file.name.padEnd(16), 0, 16, 'ascii')
+    header.write(String(mtime).padEnd(12), 16, 12, 'ascii')
+    header.write('0     ', 28, 6, 'ascii')
+    header.write('0     ', 34, 6, 'ascii')
+    header.write(mode.toString(8).padStart(6, '0').padEnd(8), 40, 8, 'ascii')
+    header.write(String(size).padEnd(10), 48, 10, 'ascii')
+    header.write('`\n', 58, 2, 'ascii')
+
+    parts.push(header)
+    parts.push(Buffer.from(file.content))
+
+    // ar members are 2-byte aligned
+    if (size % 2 !== 0) {
+      parts.push(Buffer.from('\n'))
+    }
+  }
+
+  return Buffer.concat(parts)
+}

package/src/archive/seven-za.ts

@@ -0,0 +1,160 @@
+/**
+ * 7za / xz compression wrapper.
+ * 7za is provided by the `7zip-bin` npm package, which is available on
+ * every host operating system. On Linux, xz compression uses the system
+ * `xz` executable when available.
+ */
+import { type SpawnSyncReturns, spawnSync } from 'node:child_process'
+import { existsSync, renameSync } from 'node:fs'
+import os from 'node:os'
+import { path7za } from '7zip-bin'
+
+const DEFAULT_7Z_LEVEL = 5
+
+export interface CompressOptions {
+  src: string
+  dest: string
+  format?: '7z' | 'xz'
+  level?: number
+  threads?: number
+  solid?: boolean
+  sevenZipPath?: string
+}
+
+export interface CompressResult {
+  level: number
+  threads: number
+  solid: boolean
+}
+
+export function get7zaPath(): string {
+  if (existsSync(path7za)) return path7za
+  throw new Error(`7za not found: ${path7za}`)
+}
+
+/**
+ * Parses `7z l` output for the total uncompressed size, used for the
+ * NSIS ESTIMATED_SIZE define. Returns 0 when listing fails.
+ */
+export function computeEstimatedSize(sevenZipPath: string, archiveFile: string): number {
+  const result = spawnSync(sevenZipPath, ['l', archiveFile], {
+    encoding: 'utf8',
+    stdio: 'pipe',
+    windowsHide: true,
+  })
+  if (result.status !== 0) return 0
+  const output = (result.stdout || '').trim()
+  const match = /(\d+)\s+\d+\s+\d+\s+files/.exec(output)
+  return match ? Number.parseInt(match[1], 10) : 0
+}
+
+export function compress({
+  src,
+  dest,
+  format = '7z',
+  level = DEFAULT_7Z_LEVEL,
+  threads,
+  solid = false,
+  sevenZipPath: sevenZipPathOption,
+}: CompressOptions): CompressResult {
+  const resolved = resolveCompressionOptions({ level, threads, solid })
+
+  if (format === 'xz' && process.platform === 'linux' && hasSystemXz()) {
+    compressWithSystemXz({ src, dest, level: resolved.level })
+    return resolved
+  }
+
+  const sevenZipPath = sevenZipPathOption ?? get7zaPath()
+  const { args, cwd } = build7zaAddArgs({ src, dest, format, ...resolved })
+
+  const result = spawnSync(sevenZipPath, args, { cwd, stdio: 'pipe', windowsHide: true })
+  if (result.status !== 0) {
+    throwCompressionError(format, result)
+  }
+  return resolved
+}
+
+function resolveCompressionOptions(options: {
+  level?: number
+  threads?: number
+  solid?: boolean
+}): CompressResult {
+  const level = clampLevel(options.level ?? DEFAULT_7Z_LEVEL)
+  const threads = Math.max(1, options.threads ?? os.cpus().length)
+  const solid = options.solid ?? false
+
+  return { level, threads, solid }
+}
+
+export function build7zaAddArgs({
+  src,
+  dest,
+  format = '7z',
+  level,
+  threads,
+  solid,
+}: {
+  src: string
+  dest: string
+  format?: '7z' | 'xz'
+  level: number
+  threads: number
+  solid: boolean
+}): { args: string[]; cwd: string | undefined } {
+  const formatArg = format === '7z' ? [] : [`-t${format}`]
+  const srcArg = format === '7z' ? '.' : src
+  const args = ['a', '-bd', `-mx=${level}`, ...formatArg, dest, srcArg]
+
+  if (format === '7z') {
+    args.splice(3, 0, `-mmt=${threads}`)
+    if (!solid) {
+      args.splice(3, 0, '-ms=off')
+    }
+  }
+
+  return { args, cwd: format === '7z' ? src : undefined }
+}
+
+/** Clamp a compression level to the valid 0-9 range of 7z. */
+function clampLevel(level: number): number {
+  if (!Number.isFinite(level)) {
+    return DEFAULT_7Z_LEVEL
+  }
+  return Math.min(9, Math.max(0, Math.trunc(level)))
+}
+
+function hasSystemXz(): boolean {
+  const result = spawnSync('xz', ['--version'], { stdio: 'ignore', windowsHide: true })
+  return result.status === 0
+}
+
+function compressWithSystemXz({
+  src,
+  dest,
+  level,
+}: {
+  src: string
+  dest: string
+  level: number
+}): void {
+  const result = spawnSync('xz', [`-${level}`, '-k', '-f', src], {
+    stdio: 'pipe',
+    windowsHide: true,
+  })
+  if (result.status !== 0) {
+    throwCompressionError('xz', result)
+  }
+  const defaultDest = `${src}.xz`
+  if (dest !== defaultDest) {
+    renameSync(defaultDest, dest)
+  }
+}
+
+function throwCompressionError(format: string, result: SpawnSyncReturns<Buffer>): never {
+  if (result.error) {
+    throw new Error(`${format} compression failed to spawn: ${result.error.message}`)
+  }
+  const stderr = result.stderr?.toString().trim() || ''
+  const signal = result.signal ? `, signal ${result.signal}` : ''
+  throw new Error(`${format} compression failed (exit ${result.status}${signal}): ${stderr}`)
+}

package/src/archive/tar.ts

@@ -0,0 +1,142 @@
+/**
+ * Tar entry helpers: materialize entries into a temporary directory, then
+ * pack it with `tar` while preserving per-entry modes. Mode preservation is
+ * required for setuid binaries such as chrome-sandbox.
+ */
+import { existsSync, type Stats } from 'node:fs'
+import { mkdir, readdir, readFile, readlink, rm, stat, symlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ReadEntry } from 'tar'
+import * as tar from 'tar'
+
+export type TarEntry =
+  | { type: 'dir'; path: string; mode?: number }
+  | {
+      type: 'file'
+      path: string
+      mode?: number
+      content?: Buffer
+      filePath?: string
+      getBuffer?: () => Promise<Buffer>
+    }
+  | {
+      type: 'link'
+      path: string
+      mode?: number
+      target?: string
+      getTarget?: () => Promise<string>
+    }
+
+/** Packs entries into an uncompressed tar at destPath. */
+export async function writeTarFromEntries(entries: TarEntry[], destPath: string): Promise<void> {
+  const tmpDir = `${destPath}-tmp`
+  await mkdir(tmpDir, { recursive: true })
+
+  try {
+    const modeMap = new Map<string, number | undefined>()
+
+    for (const entry of entries) {
+      const fullPath = path.join(tmpDir, entry.path)
+      const parentDir = path.dirname(fullPath)
+
+      if (entry.type === 'dir') {
+        await mkdir(fullPath, { recursive: true })
+        modeMap.set(entry.path, entry.mode)
+      } else if (entry.type === 'file') {
+        await mkdir(parentDir, { recursive: true })
+        await writeFile(fullPath, await resolveBuffer(entry))
+        modeMap.set(entry.path, entry.mode)
+      } else if (entry.type === 'link') {
+        await mkdir(parentDir, { recursive: true })
+        const target = entry.getTarget ? await entry.getTarget() : entry.target || ''
+        await symlink(target, fullPath)
+        modeMap.set(entry.path, entry.mode)
+      }
+    }
+
+    await tar.create(
+      {
+        gzip: false,
+        file: destPath,
+        cwd: tmpDir,
+        portable: true,
+        noPax: true,
+        filter: (entryPath: string, stat: ReadEntry | Stats) => {
+          const p = entryPath.replace(/^\.\//, '')
+          if (p === '.') return true
+          const mode = modeMap.get(p)
+          if (mode !== undefined) {
+            stat.mode = mode
+          }
+          return true
+        },
+      },
+      ['.'],
+    )
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true })
+  }
+}
+
+export interface CollectDirectoryOptions {
+  includeSymlinks?: boolean
+  resolveFileMode?: (input: {
+    filePath: string
+    relativePath: string
+    sourceMode: number
+  }) => number | undefined | undefined
+}
+
+/** Flattens a directory on disk into tar entries rooted at prefix. */
+export async function collectDirectoryEntries(
+  dirPath: string,
+  prefix: string,
+  options: CollectDirectoryOptions = {},
+): Promise<TarEntry[]> {
+  if (!existsSync(dirPath)) return []
+
+  const entries: TarEntry[] = []
+  await walkDir(dirPath, dirPath, prefix, entries, options)
+  return entries
+}
+
+/** Resolve a file entry's content: inline Buffer, disk path, or lazy getter. */
+async function resolveBuffer(entry: Extract<TarEntry, { type: 'file' }>): Promise<Buffer> {
+  if (entry.content) return entry.content
+  if (entry.filePath) return readFile(entry.filePath)
+  if (entry.getBuffer) return entry.getBuffer()
+  throw new Error(`TarEntry "${entry.path}" has no content source`)
+}
+
+async function walkDir(
+  rootDir: string,
+  dirPath: string,
+  prefix: string,
+  entries: TarEntry[],
+  options: CollectDirectoryOptions,
+): Promise<void> {
+  const children = await readdir(dirPath, { withFileTypes: true })
+  for (const child of children) {
+    const fullPath = path.join(dirPath, child.name)
+    const entryPath = `${prefix}/${child.name}`
+    const relativePath = path.relative(rootDir, fullPath).split(path.sep).join('/')
+
+    if (child.isDirectory()) {
+      entries.push({ type: 'dir', path: entryPath, mode: 0o40755 })
+      await walkDir(rootDir, fullPath, entryPath, entries, options)
+    } else if (child.isFile()) {
+      const s = await stat(fullPath)
+      const mode =
+        options.resolveFileMode?.({ filePath: fullPath, relativePath, sourceMode: s.mode }) ??
+        0o100644
+      entries.push({ type: 'file', path: entryPath, mode, filePath: fullPath })
+    } else if (child.isSymbolicLink() && options.includeSymlinks) {
+      entries.push({
+        type: 'link',
+        path: entryPath,
+        mode: 0o120755,
+        target: await readlink(fullPath),
+      })
+    }
+  }
+}

package/src/archive/zip-reader.ts

@@ -0,0 +1,61 @@
+/**
+ * Reads a zip archive (Electron distributions) preserving Unix permissions
+ * so symlinks and setuid bits survive repacking.
+ */
+import { readFile } from 'node:fs/promises'
+import type { JSZipObject } from 'jszip'
+import JSZip from 'jszip'
+
+const S_IFMT = 0o170000
+const S_IFLNK = 0o120000
+
+export interface ZipEntry {
+  path: string
+  dir: boolean
+  symlink: boolean
+  mode: string | number
+  entry: JSZipObject
+}
+
+export async function readZip(zipPath: string): Promise<{ entries: ZipEntry[]; zip: JSZip }> {
+  const data = await readFile(zipPath)
+  const zip = await JSZip.loadAsync(data)
+
+  const entries: ZipEntry[] = []
+  for (const [entryPath, entry] of Object.entries(zip.files)) {
+    const unixPerms = Number(entry.unixPermissions || 0)
+    const fileType = unixPerms & S_IFMT
+
+    entries.push({
+      path: entryPath,
+      dir: entry.dir,
+      symlink: fileType === S_IFLNK,
+      mode: unixPerms,
+      entry,
+    })
+  }
+
+  return { entries, zip }
+}
+
+export async function getEntryBuffer(entry: JSZipObject): Promise<Buffer> {
+  return entry.async('nodebuffer')
+}
+
+export async function getSymlinkTarget(entry: JSZipObject): Promise<string> {
+  return entry.async('text')
+}
+
+export function isSymlink(zipEntry: ZipEntry): boolean {
+  return (Number(zipEntry.mode) & S_IFMT) === S_IFLNK
+}
+
+export function isDefaultAppEntry(entryPath: string): boolean {
+  return (
+    entryPath === 'resources/app' ||
+    entryPath.startsWith('resources/app/') ||
+    entryPath === 'resources/default_app.asar' ||
+    entryPath === 'Electron.app/Contents/Resources/app' ||
+    entryPath.startsWith('Electron.app/Contents/Resources/app/')
+  )
+}