Browser Extension

#!/usr/bin/env node
/**
 * MAESTRO EXTENSION ASSET MASTER
 * 
 * Rules:
 * 1. Mandatory Icon Sizes (16, 48, 128).
 * 2. No placeholder icons (Generic names like icon.png).
 * 3. File size optimization (< 100KB for UI assets).
 */

const fs = require('fs');
const path = require('path');

/**
 * Recursively find all files in a directory.
 */
function walkDir(dir, fileList = []) {
  try {
    const files = fs.readdirSync(dir);
    for (const file of files) {
      const filePath = path.join(dir, file);
      try {
        const stat = fs.statSync(filePath);
        if (stat.isDirectory()) {
          walkDir(filePath, fileList);
        } else {
          fileList.push(filePath);
        }
      } catch (err) {
        // Skip inaccessible
      }
    }
  } catch (err) {
    // Skip inaccessible
  }
  return fileList;
}

/**
 * Audits extension assets for presence and optimization.
 */
function auditAssets(directory) {
  const issues = [];
  const requiredIcons = ['icon16.png', 'icon48.png', 'icon128.png'];
  const foundIcons = [];

  const files = walkDir(directory);

  for (const filePath of files) {
    const file = path.basename(filePath);
    const ext = path.extname(file).toLowerCase();

    if (['.png', '.jpg', '.jpeg', '.svg'].includes(ext)) {
      foundIcons.push(file);

      try {
        const stat = fs.statSync(filePath);
        const sizeKb = stat.size / 1024;

        if (sizeKb > 100) {
          issues.push(`[OPTIMIZATION] Asset '${file}' is too large (${sizeKb.toFixed(1)}KB). Max 100KB for extensions.`);
        }
      } catch (err) {
        // Skip
      }
    }
  }

  for (const req of requiredIcons) {
    if (!foundIcons.some(f => f.includes(req))) {
      issues.push(`[UX-COMPLIANCE] Missing icon size: ${req}. Store apps require exact dimensions.`);
    }
  }

  return issues;
}

/**
 * Main function.
 */
function main() {
  console.log('🎨 STARTING ASSET INTEGRITY AUDIT...');

  const targetDir = process.argv[2] || '.';
  const issues = auditAssets(targetDir);

  if (issues.length > 0) {
    console.log(`\n🚨 ${issues.length} ASSET VIOLATIONS:`);
    for (const issue of issues) {
      console.log(`  ❌ ${issue}`);
    }
    process.exit(1);
  } else {
    // Write success state
    try {
      const projectRoot = process.cwd();
      const stateDir = path.join(projectRoot, '.maestro');
      if (!fs.existsSync(stateDir)) {
        fs.mkdirSync(stateDir, { recursive: true });
      }
      fs.writeFileSync(path.join(stateDir, 'audit.state'), String(Date.now() / 1000));
    } catch (err) {
      console.log(`[WARN] Could not save audit state: ${err.message}`);
    }

    console.log('✅ ASSETS VERIFIED: Optimized and Dimensionally correct.');
    process.exit(0);
  }
}

main();

#!/usr/bin/env node
/**
 * MAESTRO MANIFEST AUDITOR (The Extension Sentinel)
 * 
 * Rules:
 * 1. Manifest v3 is mandatory.
 * 2. No 'unsafe-eval' in CSP.
 * 3. No overly broad host permissions.
 * 4. Mandatory action and background definitions.
 */

const fs = require('fs');
const path = require('path');

/**
 * Audit manifest.json for security and compliance.
 */
function auditManifest(filepath) {
  const issues = [];

  try {
    const content = fs.readFileSync(filepath, 'utf-8');
    const data = JSON.parse(content);

    // RULE 1: Manifest Version
    if (data.manifest_version !== 3) {
      issues.push("[V3-MANDATE] Manifest version must be 3. MV2 is deprecated and insecure.");
    }

    // RULE 2: CSP Security
    const csp = data.content_security_policy || {};
    const extensionPagesCsp = csp.extension_pages || '';
    if (extensionPagesCsp.includes('unsafe-eval') || extensionPagesCsp.includes('unsafe-inline')) {
      issues.push("[SECURITY-CSP] 'unsafe-eval' or 'unsafe-inline' detected in CSP. Critical security risk.");
    }

    // RULE 3: Host Permissions
    const hostPermissions = data.host_permissions || [];
    const dangerousHosts = ['<all_urls>', '*://*/*', 'http://*/*', 'https://*/*'];

    for (const host of hostPermissions) {
      if (dangerousHosts.includes(host)) {
        issues.push(`[LEAST-PRIVILEGE] Broad host permission '${host}' detected. Use specific domains.`);
      }
    }

    // RULE 4: Core Components
    if (!data.background || !data.background.service_worker) {
      issues.push("[ARCHITECTURE] Missing 'background.service_worker'. MV3 requires service worker.");
    }

    if (!data.action) {
      issues.push("[UX-ARCH] Missing 'action' definition. MV3 extensions should use 'action' for UI.");
    }

  } catch (err) {
    issues.push(`[ERROR] Could not parse manifest.json: ${err.message}`);
  }

  return issues;
}

/**
 * Main function.
 */
function main() {
  console.log('🛡️ STARTING MANIFEST SECURITY AUDIT...');

  let target = process.argv[2] || 'manifest.json';

  if (fs.existsSync(target) && fs.statSync(target).isDirectory()) {
    target = path.join(target, 'manifest.json');
  }

  if (!fs.existsSync(target)) {
    console.log(`[SKIP] ${target} not found. Skipping manifest audit.`);
    return;
  }

  const issues = auditManifest(target);

  if (issues.length > 0) {
    console.log(`\n🚨 ${issues.length} MANIFEST VIOLATIONS FOUND:`);
    for (const issue of issues) {
      console.log(`  ❌ ${issue}`);
    }
    process.exit(1);
  } else {
    // Write success state
    try {
      const projectRoot = process.cwd();
      const stateDir = path.join(projectRoot, '.maestro');
      if (!fs.existsSync(stateDir)) {
        fs.mkdirSync(stateDir, { recursive: true });
      }
      fs.writeFileSync(path.join(stateDir, 'audit.state'), String(Date.now() / 1000));
    } catch (err) {
      console.log(`[WARN] Could not save audit state: ${err.message}`);
    }

    console.log('✅ MANIFEST VERIFIED: Security & Compliance standards met.');
    process.exit(0);
  }
}

main();

#!/usr/bin/env node
/**
 * MAESTRO PERSISTENCE CHECKER (SW Survival Analyst)
 * 
 * Rules:
 * 1. Must listen to chrome.alarms.onAlarm for wakeup.
 * 2. Must use chrome.storage for state (No globals).
 * 3. Service Worker must be in the root or background/ directory.
 */

const fs = require('fs');
const path = require('path');

/**
 * Analyzes a Service Worker for persistence patterns.
 */
function checkPersistence(filepath) {
  const issues = [];

  try {
    const content = fs.readFileSync(filepath, 'utf-8');

    // RULE 1: Alarm Wakeup
    if (!content.includes('chrome.alarms.onAlarm.addListener')) {
      issues.push('[PERSISTENCE] Service Worker missing alarm listener. SW will terminate and never wake up.');
    }

    // RULE 2: Storage usage
    if (!content.includes('chrome.storage') && !content.includes('chrome.storage.local')) {
      issues.push("[STATE-LOSS] Use of 'chrome.storage' not detected. Persist state to avoid data loss on termination.");
    }

    // RULE 3: Global Variables (Naive check)
    const globalsPattern = /^(?:let|var)\s+\w+\s*=/gm;
    const globalsFound = content.match(globalsPattern) || [];

    if (globalsFound.length > 2) {
      issues.push(`[ARCHITECTURE] ${globalsFound.length} global variables detected. SW globals are ephemeral. Use storage.`);
    }
  } catch (err) {
    issues.push(`[ERROR] Could not read service worker: ${err.message}`);
  }

  return issues;
}

/**
 * Main function.
 */
function main() {
  console.log('⚡ STARTING PERSISTENCE INTEGRITY CHECK...');

  const target = process.argv[2] || 'background.js';

  if (!fs.existsSync(target)) {
    console.log(`[SKIP] ${target} not found. Skipping persistence check.`);
    return;
  }

  const issues = checkPersistence(target);

  if (issues.length > 0) {
    console.log(`\n🚨 PERSISTENCE RISKS DETECTED in ${target}:`);
    for (const issue of issues) {
      console.log(`  ⚠️ ${issue}`);
    }
    process.exit(1);
  } else {
    // Write success state
    try {
      const projectRoot = process.cwd();
      const stateDir = path.join(projectRoot, '.maestro');
      if (!fs.existsSync(stateDir)) {
        fs.mkdirSync(stateDir, { recursive: true });
      }
      fs.writeFileSync(path.join(stateDir, 'audit.state'), String(Date.now() / 1000));
    } catch (err) {
      console.log(`[WARN] Could not save audit state: ${err.message}`);
    }

    console.log('✅ PERSISTENCE VERIFIED: Pulse and State patterns detected.');
    process.exit(0);
  }
}

main();