feat: Directory cleanup and installer enhancements

- Organized build scripts into builders/ directory
- Moved config files to config/ directory
- Moved media files to assets/ directory
- Moved logs to logs/ directory
- Updated install.sh to reference builders/ paths
- Added auto-bootstrap dependencies functionality
- Added non-interactive mode support (--non-interactive, -y)
- Added automatic sudo handling
- Enhanced error handling for package installation

Author: SWORDIntel

assets/410.svg

@@ -0,0 +1,245 @@
+// K6 Load Testing Configuration for Media Hardening Service
+// Tests throughput, latency, and resource usage under load
+
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { Rate, Trend, Counter } from 'k6/metrics';
+
+// Custom metrics
+const errorRate = new Rate('errors');
+const processingDuration = new Trend('processing_duration');
+const filesProcessed = new Counter('files_processed');
+const securityViolations = new Counter('security_violations');
+
+// Load test configuration
+export const options = {
+  // Scenario 1: Smoke test (quick validation)
+  stages: [
+    { duration: '30s', target: 5 },   // Ramp up to 5 users
+    { duration: '1m', target: 5 },    // Stay at 5 users
+    { duration: '30s', target: 0 },   // Ramp down
+  ],
+
+  // Thresholds (SLOs)
+  thresholds: {
+    'http_req_duration': ['p(95)<5000'],  // 95% of requests should complete within 5s
+    'http_req_failed': ['rate<0.1'],       // Error rate should be less than 10%
+    'errors': ['rate<0.05'],               // Custom error rate threshold
+    'processing_duration': ['p(99)<10000'], // 99th percentile processing time
+  },
+
+  // Alternative scenarios (comment/uncomment as needed)
+
+  // Scenario 2: Load test (sustained load)
+  // stages: [
+  //   { duration: '2m', target: 50 },   // Ramp up to 50 users
+  //   { duration: '5m', target: 50 },   // Stay at 50 users
+  //   { duration: '2m', target: 0 },    // Ramp down
+  // ],
+
+  // Scenario 3: Stress test (find breaking point)
+  // stages: [
+  //   { duration: '2m', target: 100 },  // Ramp up to 100 users
+  //   { duration: '5m', target: 100 },  // Stay at 100
+  //   { duration: '2m', target: 200 },  // Ramp up to 200
+  //   { duration: '5m', target: 200 },  // Stay at 200
+  //   { duration: '2m', target: 0 },    // Ramp down
+  // ],
+
+  // Scenario 4: Spike test (sudden traffic spike)
+  // stages: [
+  //   { duration: '1m', target: 10 },   // Normal load
+  //   { duration: '30s', target: 200 }, // Sudden spike
+  //   { duration: '1m', target: 200 },  // Sustain spike
+  //   { duration: '30s', target: 10 },  // Return to normal
+  //   { duration: '1m', target: 0 },    // Ramp down
+  // ],
+};
+
+// Configuration
+const BASE_URL = __ENV.BASE_URL || 'http://localhost:8080';
+const MEDIA_PROCESSOR_URL = __ENV.MEDIA_PROCESSOR_URL || 'http://localhost:9000';
+
+// Sample test files (base64 encoded for convenience)
+// In production, you'd load these from actual files
+const TEST_FILES = {
+  // Minimal valid PNG (1x1 pixel, red)
+  png: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==',
+
+  // Minimal JPEG header
+  jpeg: '/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAABAAEBAREA/8QAFAABAAAAAAAAAAAAAAAAAAAACv/EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAD8AVp//2Q==',
+};
+
+// Test data generator - creates various test scenarios
+function generateTestFile(fileType, scenario = 'valid') {
+  const files = {
+    valid_png: {
+      name: 'test_valid.png',
+      data: TEST_FILES.png,
+      contentType: 'image/png',
+    },
+    valid_jpeg: {
+      name: 'test_valid.jpg',
+      data: TEST_FILES.jpeg,
+      contentType: 'image/jpeg',
+    },
+    truncated: {
+      name: 'test_truncated.png',
+      data: TEST_FILES.png.substring(0, 20), // Truncated
+      contentType: 'image/png',
+    },
+    malformed: {
+      name: 'test_malformed.jpg',
+      data: 'NOT_A_VALID_IMAGE_FILE',
+      contentType: 'image/jpeg',
+    },
+    large: {
+      name: 'test_large.bin',
+      data: 'X'.repeat(10000), // Simulate large file
+      contentType: 'application/octet-stream',
+    },
+  };
+
+  return files[scenario] || files.valid_png;
+}
+
+// Main test function
+export default function () {
+  // Select test scenario (90% valid, 10% malformed for realistic load)
+  const scenarios = ['valid_png', 'valid_jpeg', 'malformed'];
+  const weights = [0.45, 0.45, 0.10];
+  const rand = Math.random();
+  let scenario = scenarios[0];
+
+  let cumulative = 0;
+  for (let i = 0; i < scenarios.length; i++) {
+    cumulative += weights[i];
+    if (rand < cumulative) {
+      scenario = scenarios[i];
+      break;
+    }
+  }
+
+  const testFile = generateTestFile(scenario);
+
+  // Test 1: Health check endpoint
+  const healthRes = http.get(`${BASE_URL}/health`);
+  check(healthRes, {
+    'health check status 200': (r) => r.status === 200,
+  });
+
+  // Test 2: Metrics endpoint (ensure monitoring is working)
+  const metricsRes = http.get(`${BASE_URL}/metrics`);
+  check(metricsRes, {
+    'metrics endpoint accessible': (r) => r.status === 200,
+    'metrics contain expected data': (r) => r.body.includes('media_processor'),
+  });
+
+  // Test 3: Process media file (simulated via direct CLI invocation)
+  // Note: In a real setup, you'd have an HTTP API wrapper around the CLI
+  // For now, we test the monitoring endpoints
+
+  // Check for security violations in metrics
+  if (metricsRes.body.includes('security_violations_total')) {
+    const violationMatch = metricsRes.body.match(/security_violations_total{[^}]*} (\d+)/);
+    if (violationMatch && parseInt(violationMatch[1]) > 0) {
+      securityViolations.add(1);
+    }
+  }
+
+  // Track processing
+  filesProcessed.add(1);
+
+  // Record errors
+  const hasError = healthRes.status !== 200 || metricsRes.status !== 200;
+  errorRate.add(hasError);
+
+  // Simulate processing time based on file type
+  const processingTime = scenario.includes('large') ?
+    Math.random() * 3000 + 2000 : // 2-5 seconds for large files
+    Math.random() * 1000 + 500;   // 0.5-1.5 seconds for normal files
+
+  processingDuration.add(processingTime);
+
+  // Small delay between requests (realistic user behavior)
+  sleep(Math.random() * 2 + 1); // 1-3 seconds
+}
+
+// Setup function (runs once at start)
+export function setup() {
+  console.log('Starting load test...');
+  console.log(`Target: ${BASE_URL}`);
+  console.log('Scenario: Smoke test (5 concurrent users)');
+  console.log('');
+
+  // Verify service is accessible
+  const res = http.get(`${BASE_URL}/health`);
+  if (res.status !== 200) {
+    throw new Error(`Service not accessible at ${BASE_URL}`);
+  }
+
+  return { startTime: Date.now() };
+}
+
+// Teardown function (runs once at end)
+export function teardown(data) {
+  const duration = (Date.now() - data.startTime) / 1000;
+  console.log('');
+  console.log('Load test completed!');
+  console.log(`Total duration: ${duration.toFixed(2)} seconds`);
+  console.log('');
+  console.log('Check the full report above for detailed metrics.');
+  console.log('');
+  console.log('To view live metrics during the test:');
+  console.log(`  curl ${BASE_URL}/metrics`);
+  console.log('');
+  console.log('To view Grafana dashboards:');
+  console.log('  http://localhost:3000 (if running via docker-compose)');
+}
+
+// Handle HTTP errors
+export function handleSummary(data) {
+  return {
+    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
+    'load-test-results.json': JSON.stringify(data),
+  };
+}
+
+// Helper function for text summary
+function textSummary(data, options = {}) {
+  const indent = options.indent || '';
+  const enableColors = options.enableColors || false;
+
+  let output = '\n';
+  output += `${indent}Load Test Summary\n`;
+  output += `${indent}================\n\n`;
+
+  // Requests
+  const requests = data.metrics.http_reqs?.values;
+  if (requests) {
+    output += `${indent}HTTP Requests:\n`;
+    output += `${indent}  Total: ${requests.count}\n`;
+    output += `${indent}  Rate: ${requests.rate.toFixed(2)}/s\n\n`;
+  }
+
+  // Duration
+  const duration = data.metrics.http_req_duration?.values;
+  if (duration) {
+    output += `${indent}Request Duration:\n`;
+    output += `${indent}  Min: ${duration.min.toFixed(2)}ms\n`;
+    output += `${indent}  Avg: ${duration.avg.toFixed(2)}ms\n`;
+    output += `${indent}  Max: ${duration.max.toFixed(2)}ms\n`;
+    output += `${indent}  p(95): ${duration['p(95)'].toFixed(2)}ms\n`;
+    output += `${indent}  p(99): ${duration['p(99)'].toFixed(2)}ms\n\n`;
+  }
+
+  // Errors
+  const failed = data.metrics.http_req_failed?.values;
+  if (failed) {
+    const rate = (failed.rate * 100).toFixed(2);
+    output += `${indent}Errors:\n`;
+    output += `${indent}  Failed requests: ${failed.passes} (${rate}%)\n\n`;
+  }
+
+  return output;
+}

assets/Example.jpg

@@ -0,0 +1,51 @@
+# IMAGEHARDER Build Scripts
+
+This directory contains all build scripts for IMAGEHARDER components.
+
+## Build Scripts
+
+### Core Builds
+- **build.sh** - Core image libraries (GIF, PNG, JPEG)
+- **build_extended_formats.sh** - Extended formats (AVIF, JXL, TIFF, OpenEXR)
+- **build_audio.sh** - Audio codec libraries (MP3, Vorbis, Opus, FLAC)
+- **build_ffmpeg_wasm.sh** - FFmpeg WebAssembly sandbox
+- **build_all_hardened.sh** - All-in-one hardened media stack builder
+
+### Driver Builds
+- **build_hardened_drivers.sh** - Hardened video driver configurations
+- **build_hardened_audio_drivers.sh** - Hardened audio driver configurations
+
+### Setup Scripts
+- **setup_emsdk.sh** - Emscripten SDK setup for WebAssembly builds
+- **setup-cockpit.sh** - Cockpit setup (if applicable)
+
+### Testing & Verification
+- **integration-tests.sh** - Integration test suite
+- **benchmark.sh** - Benchmark tools
+- **test_corpus_generator.sh** - Test corpus generation
+- **verify_meteor_lake.sh** - Meteor Lake hardware verification
+
+### Utilities
+- **generate-sbom.sh** - Software Bill of Materials generation
+
+## Usage
+
+These scripts are called by the main orchestrator (`install.sh` in the root directory). They can also be run individually:
+
+```bash
+# Build core libraries
+./builders/build.sh
+
+# Build extended formats
+IMAGEHARDEN_CPU=host ./builders/build_extended_formats.sh
+
+# Build audio codecs
+./builders/build_audio.sh
+```
+
+## CPU Profiles
+
+Set `IMAGEHARDEN_CPU` environment variable:
+- `generic` - Generic x86-64 (default)
+- `v3` - x86-64-v3 (AVX2 baseline)
+- `host` - Native CPU (Meteor Lake optimized)