add in embedded image searching and extracting for snap

Author: willwade

src/processors/snap/helpers.ts

@@ -1,8 +1,14 @@
-import { AACTree, AACSemanticCategory, AACSemanticIntent } from '../../core/treeStructure';
+import {
+  AACTree,
+  AACSemanticCategory,
+  AACSemanticIntent,
+  AACButton,
+} from '../../core/treeStructure';
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
 import { dotNetTicksToDate } from '../../utils/dotnetTicks';
+import { ProcessorInput } from '../../utils/io';
 
 // Minimal Snap helpers (stubs) to align with processors/<engine>/helpers pattern
 // NOTE: Snap buttons currently do not populate resolvedImageEntry; these helpers
@@ -57,18 +63,84 @@ export function getPageTokenImageMap(tree: AACTree, pageId: string): Map<string,
 
 /**
  * Collect all image entry paths referenced in a Snap tree.
- * Currently empty until resolvedImageEntry is populated by the processor.
+ * Returns the set of symbol identifiers (e.g., "SYM:12345") that are referenced by buttons.
  */
-export function getAllowedImageEntries(_tree: AACTree): Set<string> {
-  return new Set<string>();
+export function getAllowedImageEntries(tree: AACTree): Set<string> {
+  const out = new Set<string>();
+  Object.values(tree.pages).forEach((page) => {
+    page.buttons.forEach((btn: AACButton) => {
+      // Extract image_id from parameters if it exists
+      if (btn.parameters?.image_id && typeof btn.parameters.image_id === 'string') {
+        out.add(btn.parameters.image_id);
+      }
+      // Also add resolvedImageEntry if it's a symbol identifier
+      if (btn.resolvedImageEntry && typeof btn.resolvedImageEntry === 'string') {
+        const entry = btn.resolvedImageEntry;
+        if (entry.startsWith('SYM:')) {
+          out.add(entry);
+        }
+      }
+    });
+  });
+  return out;
 }
 
 /**
  * Read a binary asset from a Snap pageset.
- * Not implemented yet; provided for API symmetry with other processors.
+ * @param dbOrFile Path to Snap .sps/.spb file or Buffer containing the file data
+ * @param entryPath Symbol identifier (e.g., "SYM:12345")
+ * @returns Image data buffer or null if not found
  */
-export function openImage(_dbOrFile: string | Buffer, _entryPath: string): Buffer | null {
-  return null;
+export function openImage(dbOrFile: ProcessorInput, entryPath: string): Buffer | null {
+  let dbPath: string;
+  let cleanupNeeded = false;
+
+  // Handle Buffer input by writing to temp file
+  if (Buffer.isBuffer(dbOrFile)) {
+    if (typeof fs.mkdtempSync !== 'function') {
+      return null; // Not in Node environment
+    }
+    const tempDir = fs.mkdtempSync(path.join(process.cwd(), 'snap-'));
+    dbPath = path.join(tempDir, 'temp.sps');
+    fs.writeFileSync(dbPath, dbOrFile);
+    cleanupNeeded = true;
+  } else if (typeof dbOrFile === 'string') {
+    dbPath = dbOrFile;
+  } else {
+    return null;
+  }
+
+  let db: Database.Database | null = null;
+  try {
+    db = new Database(dbPath, { readonly: true });
+
+    // Query PageSetData for the symbol
+    const row = db
+      .prepare('SELECT Id, Identifier, Data FROM PageSetData WHERE Identifier = ?')
+      .get(entryPath) as { Id: number; Identifier: string; Data: Buffer } | undefined;
+
+    if (row && row.Data && row.Data.length > 0) {
+      return row.Data;
+    }
+
+    return null;
+  } catch (error) {
+    console.warn(`[Snap helpers] Failed to open image ${entryPath}:`, error);
+    return null;
+  } finally {
+    if (db) {
+      db.close();
+    }
+    if (cleanupNeeded && dbPath) {
+      try {
+        fs.unlinkSync(dbPath);
+        const dir = path.dirname(dbPath);
+        fs.rmdirSync(dir);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  }
 }
 
 /**

src/processors/snapProcessor.ts

@@ -60,6 +60,49 @@ interface SnapPage {
   BackgroundColor?: number;
 }
 
+/**
+ * Detect image MIME type from binary data using magic bytes
+ * @param buffer Image data buffer
+ * @returns MIME type string (defaults to 'image/png' if unknown)
+ */
+function detectImageMimeType(buffer: Buffer): string {
+  if (!buffer || buffer.length < 8) {
+    return 'image/png';
+  }
+
+  // Check for PNG: 89 50 4E 47 0D 0A 1A 0A
+  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+    return 'image/png';
+  }
+
+  // Check for JPEG: FF D8 FF
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+    return 'image/jpeg';
+  }
+
+  // Check for GIF: 47 49 46 38 (GIF8)
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38) {
+    return 'image/gif';
+  }
+
+  // Check for WebP: 52 49 46 46 ... 57 45 42 50 (RIFF...WEBP)
+  if (
+    buffer[0] === 0x52 &&
+    buffer[1] === 0x49 &&
+    buffer[2] === 0x46 &&
+    buffer[3] === 0x46 &&
+    buffer[8] === 0x57 &&
+    buffer[9] === 0x45 &&
+    buffer[10] === 0x42 &&
+    buffer[11] === 0x50
+  ) {
+    return 'image/webp';
+  }
+
+  // Default to PNG
+  return 'image/png';
+}
+
 class SnapProcessor extends BaseProcessor {
   private symbolResolver: unknown | null = null;
   private loadAudio: boolean = false;
@@ -519,6 +562,38 @@ class SnapProcessor extends BaseProcessor {
             }
           }
 
+          // Load symbol image if available
+          // Note: PageSetImageId references embedded images in PageSetData table
+          // LibrarySymbolId references external symbol libraries (SymbolStix, etc.)
+          let buttonImage: string | undefined;
+          const buttonParameters: { image_id?: string; imageData?: Buffer } = {};
+          if (btnRow.PageSetImageId && btnRow.PageSetImageId > 0) {
+            try {
+              const imageData = db
+                .prepare(
+                  `
+                  SELECT Id, Identifier, Data FROM PageSetData WHERE Id = ?
+                `
+                )
+                .get(btnRow.PageSetImageId) as
+                | { Id: number; Identifier: string; Data: Buffer }
+                | undefined;
+
+              if (imageData && imageData.Data && imageData.Data.length > 0) {
+                const mimeType = detectImageMimeType(imageData.Data);
+                const base64 = imageData.Data.toString('base64');
+                buttonImage = `data:${mimeType};base64,${base64}`;
+                buttonParameters.image_id = imageData.Identifier;
+                buttonParameters.imageData = imageData.Data;
+              }
+            } catch (e) {
+              console.warn(
+                `[SnapProcessor] Failed to load image for button ${btnRow.Id} (PageSetImageId: ${btnRow.PageSetImageId}):`,
+                e
+              );
+            }
+          }
+
           // Create semantic action for Snap button
           let semanticAction: AACSemanticAction | undefined;
 
@@ -569,6 +644,9 @@ class SnapProcessor extends BaseProcessor {
             semantic_id: btnRow.LibrarySymbolId
               ? `snap_symbol_${btnRow.LibrarySymbolId}`
               : undefined, // Extract semantic_id from LibrarySymbolId
+            image: buttonImage,
+            resolvedImageEntry: buttonImage,
+            parameters: Object.keys(buttonParameters).length > 0 ? buttonParameters : undefined,
             style: {
               backgroundColor: btnRow.BackgroundColor
                 ? `#${btnRow.BackgroundColor.toString(16)}`