stegdoc 5.7.0 → 6.1.0

package/src/lib/streams.js

@@ -1,139 +1,4 @@
 const { Transform, Writable } = require('stream');
-const crypto = require('crypto');
-
-/**
- * Transform stream that converts binary input to base64 text output.
- * Buffers incomplete 3-byte groups across chunk boundaries.
- */
-class Base64EncodeTransform extends Transform {
-  constructor() {
-    super();
-    this._remainder = Buffer.alloc(0);
-  }
-
-  _transform(chunk, encoding, callback) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-    const combined = this._remainder.length > 0 ? Buffer.concat([this._remainder, buf]) : buf;
-    const usable = combined.length - (combined.length % 3);
-    if (usable > 0) {
-      this.push(combined.slice(0, usable).toString('base64'));
-    }
-    this._remainder = usable < combined.length ? combined.slice(usable) : Buffer.alloc(0);
-    callback();
-  }
-
-  _flush(callback) {
-    if (this._remainder.length > 0) {
-      this.push(this._remainder.toString('base64'));
-      this._remainder = Buffer.alloc(0);
-    }
-    callback();
-  }
-}
-
-/**
- * Transform stream that converts base64 text input to binary output.
- * Buffers incomplete 4-char groups across chunk boundaries.
- */
-class Base64DecodeTransform extends Transform {
-  constructor() {
-    super();
-    this._remainder = '';
-  }
-
-  _transform(chunk, encoding, callback) {
-    const str = this._remainder + (Buffer.isBuffer(chunk) ? chunk.toString() : chunk);
-    const usable = str.length - (str.length % 4);
-    if (usable > 0) {
-      this.push(Buffer.from(str.slice(0, usable), 'base64'));
-    }
-    this._remainder = usable < str.length ? str.slice(usable) : '';
-    callback();
-  }
-
-  _flush(callback) {
-    if (this._remainder.length > 0) {
-      this.push(Buffer.from(this._remainder, 'base64'));
-      this._remainder = '';
-    }
-    callback();
-  }
-}
-
-/**
- * Transform stream that passes data through unchanged while computing SHA-256 hash.
- * Access the hex hash via .digest after the stream has ended.
- */
-class HashPassthrough extends Transform {
-  constructor() {
-    super();
-    this._hash = crypto.createHash('sha256');
-    this._finalized = false;
-  }
-
-  _transform(chunk, encoding, callback) {
-    this._hash.update(chunk);
-    this.push(chunk);
-    callback();
-  }
-
-  _flush(callback) {
-    this._finalized = true;
-    callback();
-  }
-
-  get digest() {
-    if (!this._finalized) {
-      throw new Error('Cannot read digest before stream has ended');
-    }
-    return this._hash.digest('hex');
-  }
-}
-
-/**
- * Writable stream that collects string output up to maxBytes.
- * Calls an async onChunkReady callback when a chunk is full, applying
- * backpressure to pause upstream until the callback resolves.
- */
-class ChunkCollector extends Writable {
-  constructor(maxBytes, onChunkReady) {
-    super({ decodeStrings: false });
-    this._maxBytes = maxBytes;
-    this._buffer = '';
-    this._chunkIndex = 0;
-    this._onChunkReady = onChunkReady;
-  }
-
-  async _write(chunk, encoding, callback) {
-    try {
-      this._buffer += typeof chunk === 'string' ? chunk : chunk.toString();
-      while (this._buffer.length >= this._maxBytes) {
-        const piece = this._buffer.slice(0, this._maxBytes);
-        this._buffer = this._buffer.slice(this._maxBytes);
-        await this._onChunkReady(piece, this._chunkIndex++);
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  async _final(callback) {
-    try {
-      if (this._buffer.length > 0) {
-        await this._onChunkReady(this._buffer, this._chunkIndex++);
-        this._buffer = '';
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  get totalChunks() {
-    return this._chunkIndex;
-  }
-}
 
 /**
  * Writable stream that collects binary Buffer output up to maxBytes.
@@ -221,10 +86,6 @@ class ProgressTransform extends Transform {
 }
 
 module.exports = {
-  Base64EncodeTransform,
-  Base64DecodeTransform,
-  HashPassthrough,
-  ChunkCollector,
   BinaryChunkCollector,
   ProgressTransform,
 };

package/src/lib/utils.js

@@ -9,15 +9,6 @@ function generateHash(length = 8) {
   return crypto.randomBytes(length).toString('hex');
 }
 
-/**
- * Generate SHA-256 hash of a buffer for integrity verification
- * @param {Buffer} buffer - Data to hash
- * @returns {string} Hexadecimal SHA-256 hash
- */
-function generateContentHash(buffer) {
-  return crypto.createHash('sha256').update(buffer).digest('hex');
-}
-
 /**
  * Parse size string to bytes
  * @param {string} sizeStr - Size string (e.g., "5MB", "100KB", "1GB")
@@ -113,13 +104,6 @@ function generateFilename(hash, partNumber = null, totalParts = null, format = '
   }
 }
 
-/**
- * Legacy alias for backward compatibility
- */
-function generateDocxFilename(hash, partNumber = null, totalParts = null) {
-  return generateFilename(hash, partNumber, totalParts, 'docx').replace(/\.docx$/, '');
-}
-
 /**
  * Parse filename to extract hash, part information, and format
  * @param {string} filename - Filename to parse
@@ -195,13 +179,6 @@ function parseFilename(filename) {
   return null;
 }
 
-/**
- * Legacy alias for backward compatibility
- */
-function parseDocxFilename(filename) {
-  return parseFilename(filename);
-}
-
 /**
  * Detect file format from extension
  * @param {string} filename - Filename to check
@@ -215,13 +192,9 @@ function detectFormat(filename) {
 
 module.exports = {
   generateHash,
-  generateContentHash,
   parseSizeToBytes,
   formatBytes,
   generateFilename,
   parseFilename,
   detectFormat,
-  // Legacy aliases for backward compatibility
-  generateDocxFilename,
-  parseDocxFilename,
 };

package/src/lib/xlsx-handler.js

@@ -1,8 +1,4 @@
-const fs = require('fs');
-const path = require('path');
-const AdmZip = require('adm-zip');
-const { generateLogHeaders, encodePayloadToLogLines, decodeLogLines, resetTimeState } = require('./log-generator');
-const { parseXmlFromZip, ensureArray, extractTextContent } = require('./xml-utils');
+const { generateLogHeaders, encodePayloadToLogLines } = require('./log-generator');
 const { createXlsxRaw } = require('./xlsx-writer');
 
 const V5_SHEET_NAME = 'Access Logs';
@@ -45,273 +41,6 @@ async function createXlsxPartV5(options) {
   return outputPath;
 }
 
-/**
- * Read a v5 log-embed XLSX file and extract payload.
- * Uses fast regex-based XML scanning instead of full DOM parsing for speed.
- * @param {string} xlsxPath - Path to XLSX file
- * @returns {object} { payloadBuffer, metadataJson, encryptionMeta, metadata }
- */
-async function readXlsxV5(xlsxPath) {
-  if (!fs.existsSync(xlsxPath)) {
-    throw new Error(`XLSX file not found: ${xlsxPath}`);
-  }
-
-  // Read file once and reuse the zip instance
-  const fileBuffer = fs.readFileSync(xlsxPath);
-  const zip = new AdmZip(fileBuffer);
-
-  // Parse shared strings — handles both normal and namespace-prefixed XML (ns0:si, ns0:t)
-  let sharedStrings = null;
-  const ssEntry = zip.getEntry('xl/sharedStrings.xml');
-  if (ssEntry) {
-    sharedStrings = [];
-    const ssXml = ssEntry.getData().toString('utf8');
-    // Match <si><t>...</t></si> or <ns0:si><ns0:t>...</ns0:t></ns0:si> (any nsN prefix)
-    const siRegex = /<(?:\w+:)?si><(?:\w+:)?t[^>]*>([^<]*)<\/(?:\w+:)?t><\/(?:\w+:)?si>/g;
-    let match;
-    while ((match = siRegex.exec(ssXml)) !== null) {
-      sharedStrings.push(decodeXmlEntities(match[1]));
-    }
-  }
-
-  // Extract sheet1.xml raw string
-  const sheetEntry = zip.getEntry('xl/worksheets/sheet1.xml');
-  if (!sheetEntry) {
-    throw new Error('Sheet not found in XLSX file.');
-  }
-  const sheetXml = sheetEntry.getData().toString('utf8');
-
-  // Fast row extraction using regex — handles both normal and namespace-prefixed XML
-  const allRows = [];
-  const rowRegex = /<(?:\w+:)?row [^>]*>(.*?)<\/(?:\w+:)?row>/gs;
-  const cellRegex = /<(?:\w+:)?c r="([A-Z]+)\d+"(?: t="([^"]*)")?[^>]*>(?:<(?:\w+:)?v>([^<]*)<\/(?:\w+:)?v>|<(?:\w+:)?is><(?:\w+:)?t[^>]*>([^<]*)<\/(?:\w+:)?t><\/(?:\w+:)?is>)?<\/(?:\w+:)?c>/g;
-
-  let rowMatch;
-  while ((rowMatch = rowRegex.exec(sheetXml)) !== null) {
-    const rowXml = rowMatch[1];
-    const rowValues = [];
-
-    let cellMatch;
-    cellRegex.lastIndex = 0;
-    while ((cellMatch = cellRegex.exec(rowXml)) !== null) {
-      const colLetter = cellMatch[1];
-      const cellType = cellMatch[2] || '';
-      const vValue = cellMatch[3];
-      const inlineValue = cellMatch[4];
-
-      const colIdx = colLetterToIndex(colLetter);
-
-      let value;
-      if (cellType === 's' && vValue !== undefined && sharedStrings) {
-        const ssIndex = parseInt(vValue, 10);
-        value = ssIndex < sharedStrings.length ? sharedStrings[ssIndex] : '';
-      } else if (inlineValue !== undefined) {
-        value = decodeXmlEntities(inlineValue);
-      } else if (vValue !== undefined) {
-        value = decodeXmlEntities(vValue);
-      } else {
-        value = '';
-      }
-
-      rowValues[colIdx] = value;
-    }
-
-    allRows.push(rowValues);
-  }
-
-  // Skip the first row (column headers)
-  if (allRows.length < 2) {
-    throw new Error('Not enough rows in XLSX file for v5 format.');
-  }
-
-  const dataRows = allRows.slice(1); // Skip header row
-
-  // Decode log lines
-  return decodeLogLines(dataRows);
-}
-
-/**
- * Decode XML entities in a string value
- */
-function decodeXmlEntities(str) {
-  if (!str || !str.includes('&')) return str;
-  return str
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&apos;/g, "'")
-    .replace(/&quot;/g, '"');
-}
-
-/**
- * Convert column letter to 0-based index (A=0, B=1, ..., Z=25, AA=26)
- */
-function colLetterToIndex(letters) {
-  let index = 0;
-  for (let i = 0; i < letters.length; i++) {
-    index = index * 26 + (letters.charCodeAt(i) - 64);
-  }
-  return index - 1; // 0-based
-}
-
-/**
- * Detect whether an XLSX file is v5 (log-embed) or v3/v4 (hidden sheet) format.
- * @param {string} xlsxPath - Path to XLSX file
- * @returns {string} 'v5' or 'legacy'
- */
-function detectXlsxVersion(xlsxPath) {
-  const zip = new AdmZip(xlsxPath);
-
-  // v5 files have only sheet1.xml, v3/v4 have sheet2.xml (hidden data sheet)
-  const sheet2 = zip.getEntry('xl/worksheets/sheet2.xml');
-  if (sheet2) {
-    return 'legacy';
-  }
-
-  // Double-check: look at sheet name in workbook.xml
-  const wbEntry = zip.getEntry('xl/workbook.xml');
-  if (wbEntry) {
-    const wbXml = wbEntry.getData().toString('utf8');
-    if (wbXml.includes('Access Logs') || wbXml.includes('access_log')) {
-      return 'v5';
-    }
-  }
-
-  // Default: try v5 if only one sheet exists
-  return 'v5';
-}
-
-// ─── v3/v4 Legacy XLSX Creation (removed — no longer passes air gap filters)
-
-// ─── Unified Reader ─────────────────────────────────────────────────────────
-
-/**
- * Read an XLSX file and extract content. Auto-detects v5 vs v3/v4 format.
- * @param {string} xlsxPath - Path to XLSX file
- * @returns {Promise<object>} For v5: { payloadBuffer, metadataJson, encryptionMeta, metadata, formatVersion: 'v5' }
- *                            For legacy: { base64Content, encryptionMeta, metadata, formatVersion: 'legacy' }
- */
-async function readXlsxBase64(xlsxPath) {
-  if (!fs.existsSync(xlsxPath)) {
-    throw new Error(`XLSX file not found: ${xlsxPath}`);
-  }
-
-  const version = detectXlsxVersion(xlsxPath);
-
-  if (version === 'v5') {
-    const result = await readXlsxV5(xlsxPath);
-    return {
-      ...result,
-      formatVersion: 'v5',
-    };
-  }
-
-  const result = await extractFromXml(xlsxPath);
-  return {
-    ...result,
-    formatVersion: 'legacy',
-  };
-}
-
-// ─── Legacy XML Extraction ──────────────────────────────────────────────────
-
-async function extractFromXml(xlsxPath) {
-  let sharedStrings = [];
-  const ssParsed = parseXmlFromZip(xlsxPath, 'xl/sharedStrings.xml');
-
-  if (ssParsed && ssParsed.sst && ssParsed.sst.si) {
-    const siArray = ensureArray(ssParsed.sst.si);
-    sharedStrings = siArray.map((si) => extractTextContent(si.t));
-  }
-
-  const sheetParsed = parseXmlFromZip(xlsxPath, 'xl/worksheets/sheet2.xml');
-
-  if (!sheetParsed) {
-    throw new Error('Hidden sheet not found in XLSX file. This may not be a stegdoc-encoded file.');
-  }
-
-  const cellValues = new Map();
-  const sheetData = sheetParsed.worksheet?.sheetData;
-
-  if (sheetData && sheetData.row) {
-    const rows = ensureArray(sheetData.row);
-
-    for (const row of rows) {
-      if (!row.c) continue;
-      const cells = ensureArray(row.c);
-
-      for (const cell of cells) {
-        const cellRef = cell['@_r'];
-        const cellType = cell['@_t'];
-        const cellValue = cell.v;
-
-        if (cellRef === undefined) continue;
-
-        if (cellType === 's' && cellValue !== undefined) {
-          const ssIndex = parseInt(cellValue, 10);
-          if (ssIndex < sharedStrings.length) {
-            cellValues.set(cellRef, sharedStrings[ssIndex]);
-          }
-        } else if (cellType === 'inlineStr' && cell.is) {
-          const text = extractTextContent(cell.is.t);
-          if (text !== undefined) {
-            cellValues.set(cellRef, text);
-          }
-        } else if (cellValue !== undefined) {
-          cellValues.set(cellRef, String(cellValue));
-        }
-      }
-    }
-  }
-
-  const encryptionMeta = cellValues.get('A1') || '';
-  const metadata = cellValues.get('B1');
-  const chunkCountStr = cellValues.get('C1');
-
-  if (!metadata) {
-    throw new Error('No metadata found in XLSX file.');
-  }
-
-  const chunkCount = parseInt(chunkCountStr, 10);
-  if (isNaN(chunkCount) || chunkCount <= 0) {
-    throw new Error('Invalid chunk count in XLSX file.');
-  }
-
-  const chunks = [];
-  for (let i = 0; i < chunkCount; i++) {
-    const row = Math.floor(i / 26) + 2;
-    const col = (i % 26) + 1;
-    const cellRef = `${columnToLetter(col)}${row}`;
-    const chunk = cellValues.get(cellRef);
-    if (chunk) {
-      chunks.push(chunk);
-    }
-  }
-
-  return {
-    base64Content: chunks.join(''),
-    encryptionMeta,
-    metadata,
-  };
-}
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function columnToLetter(col) {
-  let letter = '';
-  while (col > 0) {
-    const mod = (col - 1) % 26;
-    letter = String.fromCharCode(65 + mod) + letter;
-    col = Math.floor((col - 1) / 26);
-  }
-  return letter;
-}
-
 module.exports = {
-  // v5
   createXlsxPartV5,
-  readXlsxV5,
-  detectXlsxVersion,
-  // Unified reader (auto-detects v5 vs legacy)
-  readXlsxBase64,
 };

package/src/lib/xlsx-writer.js

@@ -295,4 +295,14 @@ module.exports = {
   buildSheetXml,
   escapeXml,
   colLetter,
+  // Raw OOXML parts, exported so spec/tools/generate-xlsx-static.js can emit
+  // the Rust writer's constants from this frozen implementation.
+  CONTENT_TYPES,
+  RELS,
+  WORKBOOK_RELS,
+  STYLES,
+  THEME,
+  makeWorkbook,
+  makeCoreProps,
+  makeAppProps,
 };

package/src/lib/file-handler.js

@@ -1,113 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Read a file and encode it to base64
- * @param {string} filePath - Path to the file
- * @returns {object} Object containing base64 string, filename, extension, and size
- */
-function encodeFileToBase64(filePath) {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
-  const stats = fs.statSync(filePath);
-
-  if (!stats.isFile()) {
-    throw new Error(`Path is not a file: ${filePath}`);
-  }
-
-  const fileBuffer = fs.readFileSync(filePath);
-  const base64 = fileBuffer.toString('base64');
-  const filename = path.basename(filePath);
-  const extension = path.extname(filePath);
-
-  return {
-    base64,
-    filename,
-    extension,
-    size: stats.size,
-  };
-}
-
-/**
- * Decode base64 string and write to file
- * @param {string} base64 - Base64 encoded string
- * @param {string} outputPath - Output file path
- */
-function decodeBase64ToFile(base64, outputPath) {
-  const buffer = Buffer.from(base64, 'base64');
-
-  // Ensure output directory exists
-  const outputDir = path.dirname(outputPath);
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-
-  fs.writeFileSync(outputPath, buffer);
-}
-
-/**
- * Split base64 string into chunks based on size limit
- * @param {string} base64 - Base64 string to split
- * @param {number} chunkSizeBytes - Maximum size per chunk in bytes
- * @returns {Array<string>} Array of base64 chunks
- */
-function splitBase64(base64, chunkSizeBytes) {
-  const chunks = [];
-  let offset = 0;
-
-  while (offset < base64.length) {
-    chunks.push(base64.slice(offset, offset + chunkSizeBytes));
-    offset += chunkSizeBytes;
-  }
-
-  return chunks;
-}
-
-/**
- * Merge base64 chunks back into a single string
- * @param {Array<string>} chunks - Array of base64 chunks
- * @returns {string} Merged base64 string
- */
-function mergeBase64Chunks(chunks) {
-  return chunks.join('');
-}
-
-/**
- * Calculate how many chunks will be needed for a file
- * @param {number} fileSize - File size in bytes
- * @param {number} chunkSizeBytes - Chunk size in bytes
- * @returns {number} Number of chunks needed
- */
-function calculateChunkCount(fileSize, chunkSizeBytes) {
-  // Base64 encoding increases size by ~33%
-  const base64Size = Math.ceil(fileSize * 4 / 3);
-  return Math.ceil(base64Size / chunkSizeBytes);
-}
-
-/**
- * Validate if a path is writable
- * @param {string} dirPath - Directory path to check
- * @returns {boolean} True if writable
- */
-function isDirectoryWritable(dirPath) {
-  try {
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
-    }
-    fs.accessSync(dirPath, fs.constants.W_OK);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-module.exports = {
-  encodeFileToBase64,
-  decodeBase64ToFile,
-  splitBase64,
-  mergeBase64Chunks,
-  calculateChunkCount,
-  isDirectoryWritable,
-};