dsh-desktop-kit 0.0.0-stage → 2.0.0

package/skills/seo/assets/scripts/lib/zip.mjs

@@ -0,0 +1,191 @@
+// Минимальный ZIP-ридер без внешних зависимостей (store + deflate, CRC32).
+// Нужен валидатору, чтобы читать нужные файлы прямо из архива, не распаковывая всё в temp.
+// ZIP64 и шифрованные архивы не поддерживаются — для портативного пакета DSH это не нужно.
+
+import fs from 'node:fs';
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
+
+const EOCD_SIG = 0x06054b50;
+const CD_SIG = 0x02014b50;
+const LFH_SIG = 0x04034b50;
+
+export class ZipError extends Error {
+  constructor(message, code = 'zip') {
+    super(message);
+    this.name = 'ZipError';
+    this.code = code;
+  }
+}
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+export function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+export function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+/** Декодирование имени записи: UTF-8 по флагу, иначе UTF-8/ibm866/latin1. */
+function decodeName(buf, flags) {
+  if (flags & 0x800) {
+    try {
+      return new TextDecoder('utf-8', { fatal: true }).decode(buf);
+    } catch {
+      /* fallthrough */
+    }
+  }
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(buf);
+  } catch {
+    try {
+      return new TextDecoder('ibm866').decode(buf); // OEM-кодировка русской Windows
+    } catch {
+      return buf.toString('latin1');
+    }
+  }
+}
+
+/**
+ * Прочитать ZIP-архив целиком в память и разобрать оглавление.
+ * @returns {{filePath:string, fileSize:number, archiveSha256:string, entries:Array, files:Array, dirs:Array, read:Function, readPath:Function, warnings:string[]}}
+ */
+export function readZip(filePath) {
+  const buf = fs.readFileSync(filePath);
+  const warnings = [];
+
+  let eocd = -1;
+  const minPos = Math.max(0, buf.length - 22 - 65535);
+  for (let i = buf.length - 22; i >= minPos; i--) {
+    if (buf.readUInt32LE(i) === EOCD_SIG) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new ZipError('Не найден EOCD (конец центрального каталога) — файл повреждён или это не ZIP', 'corrupt');
+
+  const disk = buf.readUInt16LE(eocd + 4);
+  const cdDisk = buf.readUInt16LE(eocd + 6);
+  const entriesDisk = buf.readUInt16LE(eocd + 8);
+  const entriesTotal = buf.readUInt16LE(eocd + 10);
+  const cdSize = buf.readUInt32LE(eocd + 12);
+  const cdOffset = buf.readUInt32LE(eocd + 16);
+  const commentLen = buf.readUInt16LE(eocd + 20);
+  if (eocd + 22 + commentLen > buf.length) warnings.push('EOCD-комментарий выходит за границу файла');
+  if (disk !== 0 || cdDisk !== 0 || entriesDisk !== entriesTotal) {
+    throw new ZipError('Многотомные ZIP не поддерживаются', 'unsupported');
+  }
+  if (cdOffset === 0xffffffff || cdSize === 0xffffffff || entriesTotal === 0xffff) {
+    throw new ZipError('ZIP64 не поддерживается валидатором', 'unsupported');
+  }
+  if (cdOffset + cdSize > buf.length) {
+    throw new ZipError('Центральный каталог выходит за границу файла — архив обрезан', 'corrupt');
+  }
+
+  const entries = [];
+  let p = cdOffset;
+  for (let i = 0; i < entriesTotal; i++) {
+    if (p + 46 > buf.length || buf.readUInt32LE(p) !== CD_SIG) {
+      throw new ZipError(`Повреждён центральный каталог ZIP (запись ${i + 1})`, 'corrupt');
+    }
+    const flags = buf.readUInt16LE(p + 8);
+    const method = buf.readUInt16LE(p + 10);
+    const crc = buf.readUInt32LE(p + 16);
+    const compSize = buf.readUInt32LE(p + 20);
+    const uncompSize = buf.readUInt32LE(p + 24);
+    const nameLen = buf.readUInt16LE(p + 28);
+    const extraLen = buf.readUInt16LE(p + 30);
+    const commentLen2 = buf.readUInt16LE(p + 32);
+    const extAttr = buf.readUInt32LE(p + 38);
+    const localOffset = buf.readUInt32LE(p + 42);
+    if (compSize === 0xffffffff || uncompSize === 0xffffffff || localOffset === 0xffffffff) {
+      throw new ZipError(`ZIP64-запись не поддерживается: ${decodeName(buf.subarray(p + 46, p + 46 + nameLen), flags)}`, 'unsupported');
+    }
+    const name = decodeName(buf.subarray(p + 46, p + 46 + nameLen), flags);
+    p += 46 + nameLen + extraLen + commentLen2;
+
+    const unixMode = (extAttr >>> 16) & 0xffff;
+    const isDir = name.endsWith('/') || (unixMode & 0o170000) === 0o040000 || (extAttr & 0x10) !== 0;
+    entries.push({
+      path: name.replace(/\\/g, '/'),
+      rawName: name,
+      isDir,
+      size: uncompSize,
+      compSize,
+      crc,
+      method,
+      flags,
+      encrypted: (flags & 1) !== 0,
+      localOffset,
+      extAttr,
+    });
+  }
+
+  const byPath = new Map(entries.map((e) => [e.path, e]));
+
+  function read(entry) {
+    if (!entry || entry.isDir) return Buffer.alloc(0);
+    if (entry.encrypted) throw new ZipError(`Запись зашифрована: ${entry.path}`, 'unsupported');
+    const off = entry.localOffset;
+    if (off + 30 > buf.length || buf.readUInt32LE(off) !== LFH_SIG) {
+      throw new ZipError(`Повреждён локальный заголовок записи: ${entry.path}`, 'corrupt');
+    }
+    const nameLen = buf.readUInt16LE(off + 26);
+    const extraLen = buf.readUInt16LE(off + 28);
+    const dataStart = off + 30 + nameLen + extraLen;
+    if (dataStart + entry.compSize > buf.length) {
+      throw new ZipError(`Обрезаны данные записи: ${entry.path}`, 'corrupt');
+    }
+    const compressed = buf.subarray(dataStart, dataStart + entry.compSize);
+    let data;
+    if (entry.method === 0) data = Buffer.from(compressed);
+    else if (entry.method === 8) {
+      try {
+        data = zlib.inflateRawSync(compressed);
+      } catch (e) {
+        throw new ZipError(`Ошибка распаковки (deflate): ${entry.path} — ${e.message}`, 'corrupt');
+      }
+    } else {
+      throw new ZipError(`Метод сжатия ${entry.method} не поддерживается: ${entry.path}`, 'unsupported');
+    }
+    if (data.length !== entry.size) {
+      throw new ZipError(`Размер записи не совпал (${data.length} != ${entry.size}): ${entry.path}`, 'corrupt');
+    }
+    const actual = crc32(data);
+    if (actual !== entry.crc) {
+      throw new ZipError(`CRC32 не совпал: ${entry.path}`, 'corrupt');
+    }
+    return data;
+  }
+
+  return {
+    filePath,
+    fileSize: buf.length,
+    archiveSha256: sha256(buf),
+    entries,
+    files: entries.filter((e) => !e.isDir),
+    dirs: entries.filter((e) => e.isDir),
+    read,
+    readPath(name) {
+      const entry = byPath.get(name.replace(/\\/g, '/'));
+      if (!entry) throw new ZipError(`Нет записи в архиве: ${name}`, 'missing');
+      return read(entry);
+    },
+    hasPath(name) {
+      return byPath.has(name.replace(/\\/g, '/'));
+    },
+    warnings,
+  };
+}