stegdoc 4.0.0 → 5.0.0

package/src/lib/file-utils.js

@@ -1,150 +1,160 @@
-const fs = require('fs');
-const path = require('path');
-const { parseMetadata } = require('./metadata');
-const { parseFilename } = require('./utils');
-
-/**
- * Extract content and metadata based on format
- * @param {object} readResult - Result from readFile
- * @param {string} format - File format ('xlsx' or 'docx')
- * @returns {object} { encryptedContent, encryptionMeta, metadata }
- */
-function extractContent(readResult, format) {
-  if (format === 'xlsx') {
-    return {
-      encryptedContent: readResult.base64Content,
-      encryptionMeta: readResult.encryptionMeta,
-      metadata: parseMetadata(readResult.metadata),
-    };
-  } else {
-    // DOCX: encryption meta is embedded in content with ||| separator
-    const { base64Content, metadata } = readResult;
-
-    // Check if this is a v2+ encrypted file
-    if (base64Content.includes('|||')) {
-      const [encryptionMeta, encryptedContent] = base64Content.split('|||');
-      return {
-        encryptedContent,
-        encryptionMeta,
-        metadata,
-      };
-    }
-
-    // Legacy unencrypted DOCX
-    return {
-      encryptedContent: base64Content,
-      encryptionMeta: null,
-      metadata,
-    };
-  }
-}
-
-/**
- * Find all parts of a multi-part file in a directory
- * @param {string} dirPath - Directory to search
- * @param {string} hash - Original hash from metadata
- * @param {string} format - File format ('xlsx' or 'docx')
- * @param {number} [expectedParts] - Expected total parts (optional, for validation)
- * @returns {Array<{path: string, partNumber: number, filename: string}>} Array of parts sorted by part number
- */
-function findMultiPartFiles(dirPath, hash, format, expectedParts = null) {
-  const files = fs.readdirSync(dirPath);
-  const parts = [];
-  const ext = format === 'docx' ? '.docx' : '.xlsx';
-
-  // Also support legacy hex filenames for backward compatibility
-  const legacyBaseHash = hash.length >= 16 ? hash.slice(0, 16) : hash;
-
-  for (const file of files) {
-    if (!file.toLowerCase().endsWith(ext)) continue;
-
-    const parsed = parseFilename(file);
-    if (!parsed || parsed.partNumber === null) continue;
-
-    // Match by new realistic filename pattern
-    // Check if file matches the expected pattern (same reportId from hash)
-    if (parsed.reportId) {
-      // New realistic format - match by reportId (last 4 chars of hash)
-      // This is deterministic and doesn't depend on current date
-      const expectedReportId = hash.slice(-4).toUpperCase();
-      if (parsed.reportId === expectedReportId) {
-        parts.push({
-          path: path.join(dirPath, file),
-          partNumber: parsed.partNumber,
-          filename: file,
-          dateStr: parsed.dateStr,
-          timeStr: parsed.timeStr,
-        });
-      }
-    } else if (parsed.baseHash === legacyBaseHash) {
-      // Legacy hex format - match by base hash
-      parts.push({
-        path: path.join(dirPath, file),
-        partNumber: parsed.partNumber,
-        filename: file,
-      });
-    }
-  }
-
-  // Sort by part number
-  parts.sort((a, b) => a.partNumber - b.partNumber);
-
-  // For realistic filenames, ensure all parts have the same date/time pattern
-  // This handles edge cases where multiple file sets might share the same reportId
-  if (parts.length > 0 && parts[0].dateStr) {
-    const refDateStr = parts[0].dateStr;
-    const refTimeStr = parts[0].timeStr;
-    const filteredParts = parts.filter(
-      (p) => p.dateStr === refDateStr && p.timeStr === refTimeStr
-    );
-    // If filtering removed some parts, use the filtered set
-    if (filteredParts.length !== parts.length) {
-      parts.length = 0;
-      parts.push(...filteredParts);
-    }
-  }
-
-  // Validate sequential parts if expectedParts is provided
-  if (expectedParts !== null && parts.length === expectedParts) {
-    for (let i = 0; i < expectedParts; i++) {
-      if (parts[i].partNumber !== i + 1) {
-        throw new Error(`Missing part ${i + 1}. Parts must be sequential.`);
-      }
-    }
-  }
-
-  return parts;
-}
-
-/**
- * Check if a directory 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 {
-    return false;
-  }
-}
-
-/**
- * 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('');
-}
-
-module.exports = {
-  extractContent,
-  findMultiPartFiles,
-  isDirectoryWritable,
-  mergeBase64Chunks,
-};
+const fs = require('fs');
+const path = require('path');
+const { parseMetadata } = require('./metadata');
+const { parseFilename } = require('./utils');
+
+/**
+ * Extract content and metadata based on format
+ * @param {object} readResult - Result from readFile
+ * @param {string} format - File format ('xlsx' or 'docx')
+ * @returns {object} { encryptedContent, encryptionMeta, metadata }
+ */
+function extractContent(readResult, format) {
+  // v5 log-embed format returns metadata already parsed
+  if (readResult.formatVersion === 'v5') {
+    return {
+      encryptedContent: null, // v5 uses payloadBuffer instead
+      encryptionMeta: readResult.encryptionMeta,
+      metadata: readResult.metadata,
+      payloadBuffer: readResult.payloadBuffer,
+    };
+  }
+
+  if (format === 'xlsx') {
+    return {
+      encryptedContent: readResult.base64Content,
+      encryptionMeta: readResult.encryptionMeta,
+      metadata: parseMetadata(readResult.metadata),
+    };
+  } else {
+    // DOCX: encryption meta is embedded in content with ||| separator
+    const { base64Content, metadata } = readResult;
+
+    // Check if this is a v2+ encrypted file
+    if (base64Content.includes('|||')) {
+      const [encryptionMeta, encryptedContent] = base64Content.split('|||');
+      return {
+        encryptedContent,
+        encryptionMeta,
+        metadata,
+      };
+    }
+
+    // Legacy unencrypted DOCX
+    return {
+      encryptedContent: base64Content,
+      encryptionMeta: null,
+      metadata,
+    };
+  }
+}
+
+/**
+ * Find all parts of a multi-part file in a directory
+ * @param {string} dirPath - Directory to search
+ * @param {string} hash - Original hash from metadata
+ * @param {string} format - File format ('xlsx' or 'docx')
+ * @param {number} [expectedParts] - Expected total parts (optional, for validation)
+ * @returns {Array<{path: string, partNumber: number, filename: string}>} Array of parts sorted by part number
+ */
+function findMultiPartFiles(dirPath, hash, format, expectedParts = null) {
+  const files = fs.readdirSync(dirPath);
+  const parts = [];
+  const ext = format === 'docx' ? '.docx' : '.xlsx';
+
+  // Also support legacy hex filenames for backward compatibility
+  const legacyBaseHash = hash.length >= 16 ? hash.slice(0, 16) : hash;
+
+  for (const file of files) {
+    if (!file.toLowerCase().endsWith(ext)) continue;
+
+    const parsed = parseFilename(file);
+    if (!parsed || parsed.partNumber === null) continue;
+
+    // Match by new realistic filename pattern
+    // Check if file matches the expected pattern (same reportId from hash)
+    if (parsed.reportId) {
+      // New realistic format - match by reportId (last 4 chars of hash)
+      // This is deterministic and doesn't depend on current date
+      const expectedReportId = hash.slice(-4).toUpperCase();
+      if (parsed.reportId === expectedReportId) {
+        parts.push({
+          path: path.join(dirPath, file),
+          partNumber: parsed.partNumber,
+          filename: file,
+          dateStr: parsed.dateStr,
+          timeStr: parsed.timeStr,
+        });
+      }
+    } else if (parsed.baseHash === legacyBaseHash) {
+      // Legacy hex format - match by base hash
+      parts.push({
+        path: path.join(dirPath, file),
+        partNumber: parsed.partNumber,
+        filename: file,
+      });
+    }
+  }
+
+  // Sort by part number
+  parts.sort((a, b) => a.partNumber - b.partNumber);
+
+  // For realistic filenames, ensure all parts have the same date/time pattern
+  // This handles edge cases where multiple file sets might share the same reportId
+  if (parts.length > 0 && parts[0].dateStr) {
+    const refDateStr = parts[0].dateStr;
+    const refTimeStr = parts[0].timeStr;
+    const filteredParts = parts.filter(
+      (p) => p.dateStr === refDateStr && p.timeStr === refTimeStr
+    );
+    // If filtering removed some parts, use the filtered set
+    if (filteredParts.length !== parts.length) {
+      parts.length = 0;
+      parts.push(...filteredParts);
+    }
+  }
+
+  // Validate sequential parts if expectedParts is provided
+  if (expectedParts !== null && parts.length === expectedParts) {
+    for (let i = 0; i < expectedParts; i++) {
+      if (parts[i].partNumber !== i + 1) {
+        throw new Error(`Missing part ${i + 1}. Parts must be sequential.`);
+      }
+    }
+  }
+
+  return parts;
+}
+
+/**
+ * Check if a directory 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 {
+    return false;
+  }
+}
+
+/**
+ * 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('');
+}
+
+module.exports = {
+  extractContent,
+  findMultiPartFiles,
+  isDirectoryWritable,
+  mergeBase64Chunks,
+};