browser-extension-manager 1.2.12 → 1.2.14

package/dist/config/manifest.json

@@ -90,7 +90,7 @@
   // IDs
   browser_specific_settings: {
     gecko: {
-      id: 'my-addon@example.com',
+      // id: 'my-addon@example.com',
       strict_min_version: '91.0',
       // Required for new Firefox extensions as of Nov 2025
       // https://blog.mozilla.org/addons/2025/10/23/data-collection-consent-changes-for-new-firefox-extensions/

package/dist/gulp/config/locales.js

@@ -0,0 +1,30 @@
+// Locale field limits (Chrome Web Store requirements)
+// https://developer.chrome.com/docs/webstore/i18n
+module.exports = {
+  // Field character limits
+  limits: {
+    appName: 50,
+    appNameShort: 25,
+    appDescription: 200,
+  },
+
+  // Languages to translate (code: name)
+  languages: {
+    zh: 'Chinese (Simplified)',
+    es: 'Spanish',
+    hi: 'Hindi',
+    ar: 'Arabic',
+    pt: 'Portuguese',
+    ru: 'Russian',
+    ja: 'Japanese',
+    de: 'German',
+    fr: 'French',
+    ko: 'Korean',
+    ur: 'Urdu',
+    id: 'Indonesian',
+    bn: 'Bengali',
+    tl: 'Tagalog/Filipino',
+    vi: 'Vietnamese',
+    it: 'Italian',
+  },
+};

package/dist/gulp/tasks/audit.js

@@ -15,6 +15,7 @@ const rootPathProject = Manager.getRootPath('project');
 // Audit results tracker
 const auditResults = {
   externalScripts: [],
+  localeWarnings: [],
 };
 
 // Patterns to detect external script references
@@ -38,6 +39,44 @@ const EXTERNAL_SCRIPT_PATTERNS = [
   /["'](https?:\/\/(?:www\.)?(?:google\.com\/recaptcha|apis\.google\.com)[^"']*)["']/gi,
 ];
 
+// Locale config (shared with translate.js)
+const { limits: LOCALE_LIMITS } = require('../config/locales.js');
+
+// Check locale files for warnings
+function checkLocaleFiles(packagedDir) {
+  const localesDir = path.join(packagedDir, '_locales');
+
+  if (!jetpack.exists(localesDir)) {
+    return;
+  }
+
+  const localeFiles = jetpack.find(localesDir, { matching: '*/messages.json' });
+
+  localeFiles.forEach(filePath => {
+    try {
+      const content = jetpack.read(filePath);
+      const messages = JSON.parse(content);
+
+      // Check each field against its limit
+      Object.entries(LOCALE_LIMITS).forEach(([field, limit]) => {
+        const message = messages[field]?.message;
+
+        if (message && message.length > limit) {
+          auditResults.localeWarnings.push({
+            file: path.relative(rootPathProject, filePath),
+            field: field,
+            length: message.length,
+            limit: limit,
+            value: message,
+          });
+        }
+      });
+    } catch (e) {
+      logger.warn(`Error parsing locale file ${filePath}: ${e.message}`);
+    }
+  });
+}
+
 // Check a single file for external script references
 function checkFileForExternalScripts(filePath) {
   try {
@@ -86,10 +125,11 @@ async function auditFn(complete) {
 
   // Reset results
   auditResults.externalScripts = [];
+  auditResults.localeWarnings = [];
 
   try {
-    // Find all files in packaged directory (JS, HTML, etc.)
-    const packagedDir = path.join(rootPathProject, 'packaged', 'raw');
+    // Audit chromium build (code is same for both targets, only manifest differs)
+    const packagedDir = path.join(rootPathProject, 'packaged', 'chromium', 'raw');
 
     if (!jetpack.exists(packagedDir)) {
       logger.log(chalk.yellow('⚠️  Packaged directory not found. Run package task first.'));
@@ -100,7 +140,7 @@ async function auditFn(complete) {
 
     logger.log(`Auditing ${files.length} files (JS, HTML)...`);
 
-    // Check each file
+    // Check each file for external scripts
     files.forEach(filePath => {
       const externalScripts = checkFileForExternalScripts(filePath);
       if (externalScripts.length > 0) {
@@ -108,6 +148,9 @@ async function auditFn(complete) {
       }
     });
 
+    // Check locale files
+    checkLocaleFiles(packagedDir);
+
     // Display results
     displayAuditResults();
 
@@ -142,6 +185,23 @@ function displayAuditResults() {
     console.log(chalk.green('✅ No external scripts detected'));
   }
 
+  console.log('');
+
+  // Locale Warnings
+  if (auditResults.localeWarnings.length > 0) {
+    console.log(chalk.yellow.bold('⚠️  LOCALE FIELD LENGTH WARNINGS'));
+    console.log(chalk.gray('Some locale fields exceed recommended character limits.\n'));
+
+    auditResults.localeWarnings.forEach((item, index) => {
+      console.log(chalk.yellow(`  ${index + 1}. ${item.file}`));
+      console.log(chalk.gray(`     Field: ${item.field} (${item.length}/${item.limit} chars)`));
+      console.log(chalk.gray(`     Value: "${item.value}"`));
+      console.log('');
+    });
+  } else {
+    console.log(chalk.green('✅ All locale fields within limits'));
+  }
+
   // Summary
   console.log(chalk.bold('\n───────────────────────────────────────────────────'));
   console.log(chalk.bold('SUMMARY'));
@@ -151,6 +211,10 @@ function displayAuditResults() {
   const externalScriptColor = externalScriptCount > 0 ? chalk.red : chalk.green;
   console.log(externalScriptColor(`External Scripts: ${externalScriptCount}`));
 
+  const localeWarningCount = auditResults.localeWarnings.length;
+  const localeWarningColor = localeWarningCount > 0 ? chalk.yellow : chalk.green;
+  console.log(localeWarningColor(`Locale Warnings: ${localeWarningCount}`));
+
   console.log(chalk.bold('═══════════════════════════════════════════════════\n'));
 }
 

package/dist/gulp/tasks/package.js

@@ -152,8 +152,11 @@ function getPackageVersion(packageName) {
   }
 }
 
+// Build targets
+const TARGETS = ['chromium', 'firefox'];
+
 // Special Compilation Task for manifest.json with default settings
-async function compileManifest(outputDir) {
+async function compileManifest(outputDir, target) {
   try {
     const manifestPath = path.join('dist', 'manifest.json');
     const outputPath = path.join(outputDir, 'manifest.json');
@@ -189,10 +192,27 @@ async function compileManifest(outputDir) {
     // Add package version to manifest
     manifest.version = project.version;
 
+    // Apply target-specific manifest adjustments
+    if (manifest.background) {
+      if (target === 'chromium') {
+        // Chrome/Edge uses service_worker only
+        delete manifest.background.scripts;
+      } else if (target === 'firefox') {
+        // Firefox uses scripts array only
+        if (manifest.background.service_worker) {
+          // Ensure scripts array exists (derive from service_worker if needed)
+          if (!manifest.background.scripts) {
+            manifest.background.scripts = [manifest.background.service_worker];
+          }
+          delete manifest.background.service_worker;
+        }
+      }
+    }
+
     // Save as regular JSON
     jetpack.write(outputPath, JSON.stringify(manifest, null, 2));
 
-    logger.log(`Manifest compiled with defaults`);
+    logger.log(`[${target}] Manifest compiled with defaults`);
   } catch (e) {
     logger.error(`Error compiling manifest`, e);
   }
@@ -225,76 +245,92 @@ async function compileLocales(outputDir) {
   }
 }
 
-// Package Task for raw
+// Package Task for raw - creates both chromium and firefox builds
 async function packageRaw() {
   // Log
   logger.log(`Starting raw packaging...`);
 
   try {
-    const outputDir = 'packaged/raw';
+    // Build for each target
+    for (const target of TARGETS) {
+      await packageRawForTarget(target);
+    }
 
-    // Ensure the directory exists
-    jetpack.dir(outputDir);
+    // Log completion
+    logger.log(`Finished raw packaging for all targets`);
+  } catch (e) {
+    logger.error(`Error during raw packaging`, e);
+  }
+}
+
+// Package raw for a specific target (chromium or firefox)
+async function packageRawForTarget(target) {
+  logger.log(`[${target}] Starting raw packaging...`);
+
+  const outputDir = `packaged/${target}/raw`;
 
-    // Copy files to raw package directory
-    await execute(`cp -r dist/* ${outputDir}`);
+  // Ensure the directory exists (this also cleans it)
+  jetpack.dir(outputDir, { empty: true });
 
-    // Loop thru outputDir/dist/assets/js all JS files
-    const jsFiles = jetpack.find(path.join(outputDir, 'assets', 'js'), { matching: '*.js' });
-    const redactions = getRedactions();
+  // Copy files to raw package directory
+  await execute(`cp -r dist/* ${outputDir}`);
 
-    jsFiles.forEach(filePath => {
-      // Load the content
-      let content = jetpack.read(filePath);
+  // Loop thru outputDir/assets/js all JS files for redactions
+  const jsFiles = jetpack.find(path.join(outputDir, 'assets', 'js'), { matching: '*.js' });
+  const redactions = getRedactions();
 
-      // Replace keys with their corresponding values
-      Object.keys(redactions).forEach(key => {
-        const value = redactions[key];
-        const regex = new RegExp(key, 'g'); // Create a global regex for the key
-        content = content.replace(regex, value);
+  jsFiles.forEach(filePath => {
+    // Load the content
+    let content = jetpack.read(filePath);
 
-        // Log replacement
-        logger.log(`Redacted ${key} in ${filePath}`);
-      });
+    // Replace keys with their corresponding values
+    Object.keys(redactions).forEach(key => {
+      const value = redactions[key];
+      const regex = new RegExp(key, 'g'); // Create a global regex for the key
+      content = content.replace(regex, value);
 
-      // Write the new content to the file
-      jetpack.write(filePath, content);
+      // Log replacement
+      logger.log(`[${target}] Redacted ${key} in ${filePath}`);
     });
 
-    // Generate build.js and build.json
-    await generateBuildJs(outputDir);
+    // Write the new content to the file
+    jetpack.write(filePath, content);
+  });
 
-    // Compile manifest and locales
-    await compileManifest(outputDir);
-    await compileLocales(outputDir);
+  // Generate build.js and build.json
+  await generateBuildJs(outputDir);
 
-    // Log completion
-    logger.log(`Finished raw packaging`);
-  } catch (e) {
-    logger.error(`Error during raw packaging`, e);
-  }
+  // Compile manifest (target-specific) and locales
+  await compileManifest(outputDir, target);
+  await compileLocales(outputDir);
+
+  logger.log(`[${target}] Finished raw packaging`);
 }
 
-// Create zipped version of raw package
+// Create zipped version of raw packages for each target
 async function packageZip() {
   // Log
-  logger.log(`Zipping raw package...`);
+  logger.log(`Zipping raw packages...`);
+
+  // Skip if not in build mode
+  if (!Manager.isBuildMode()) {
+    logger.log(`Skipping zip (not in build mode)`);
+    return;
+  }
 
   try {
-    const inputDir = 'packaged/raw';
-    const zipPath = 'packaged/extension.zip';
+    // Create zip for each target
+    for (const target of TARGETS) {
+      const inputDir = `packaged/${target}/raw`;
+      const zipPath = `packaged/${target}/extension.zip`;
 
-    // Create packed extension (.zip)
-    if (Manager.isBuildMode()) {
       // Remove existing zip if it exists
       jetpack.remove(zipPath);
 
       // Zip contents of raw directory (not the directory itself)
       // This ensures manifest.json is at the root of the zip
-      await execute(`cd ${inputDir} && zip -r ../../${zipPath} .`);
-      logger.log(`Zipped package created at ${zipPath}`);
-    } else {
-      logger.log(`Skipping zip (not in build mode)`);
+      await execute(`cd ${inputDir} && zip -r ../extension.zip .`);
+      logger.log(`[${target}] Zipped package created at ${zipPath}`);
     }
   } catch (e) {
     logger.error(`Error zipping package`, e);

package/dist/gulp/tasks/publish.js

@@ -9,8 +9,17 @@ const { execute } = require('node-powertools');
 // Load package
 const project = Manager.getPackage('project');
 
-// Paths
-const zipPath = path.join(process.cwd(), 'packaged', 'extension.zip');
+// Paths for each target
+const PATHS = {
+  chromium: {
+    zip: path.join(process.cwd(), 'packaged', 'chromium', 'extension.zip'),
+    raw: path.join(process.cwd(), 'packaged', 'chromium', 'raw'),
+  },
+  firefox: {
+    zip: path.join(process.cwd(), 'packaged', 'firefox', 'extension.zip'),
+    raw: path.join(process.cwd(), 'packaged', 'firefox', 'raw'),
+  },
+};
 
 // Helper to check if a credential is valid (not empty or placeholder)
 function isValidCredential(value) {
@@ -56,9 +65,13 @@ async function publish(complete) {
   // Log
   logger.log('Starting publish...');
 
-  // Check if zip exists
-  if (!jetpack.exists(zipPath)) {
-    logger.error(`Extension zip not found at ${zipPath}. Run build first.`);
+  // Check if zips exist for each target
+  const missingZips = Object.entries(PATHS)
+    .filter(([, paths]) => !jetpack.exists(paths.zip))
+    .map(([target]) => target);
+
+  if (missingZips.length > 0) {
+    logger.error(`Extension zips not found for: ${missingZips.join(', ')}. Run build first.`);
     return complete();
   }
 
@@ -158,10 +171,10 @@ async function publishToChrome() {
 
   logger.log('[chrome] Uploading to Chrome Web Store...');
 
-  // Use chrome-webstore-upload-cli
+  // Use chrome-webstore-upload-cli with chromium build
   const command = [
     'npx chrome-webstore-upload-cli',
-    `--source "${zipPath}"`,
+    `--source "${PATHS.chromium.zip}"`,
     `--extension-id "${extensionId}"`,
     `--client-id "${clientId}"`,
     `--client-secret "${clientSecret}"`,
@@ -188,11 +201,10 @@ async function publishToFirefox() {
 
   logger.log('[firefox] Uploading to Firefox Add-ons...');
 
-  // Use web-ext sign
-  const rawDir = path.join(process.cwd(), 'packaged', 'raw');
+  // Use web-ext sign with firefox build
   const command = [
     'npx web-ext sign',
-    `--source-dir "${rawDir}"`,
+    `--source-dir "${PATHS.firefox.raw}"`,
     `--api-key "${apiKey}"`,
     `--api-secret "${apiSecret}"`,
     `--channel "${channel}"`,
@@ -218,8 +230,8 @@ async function publishToEdge() {
 
   logger.log('[edge] Uploading to Microsoft Edge Add-ons...');
 
-  // Read zip file
-  const zipBuffer = jetpack.read(zipPath, 'buffer');
+  // Read chromium zip file (Edge uses same build as Chrome)
+  const zipBuffer = jetpack.read(PATHS.chromium.zip, 'buffer');
 
   // Edge API v1.1 endpoint
   const uploadUrl = `https://api.addons.microsoftedge.microsoft.com/v1/products/${productId}/submissions/draft/package`;

package/dist/gulp/tasks/translate.js

@@ -7,25 +7,8 @@ const path = require('path');
 const { execute } = require('node-powertools');
 const JSON5 = require('json5');
 
-// Languages to translate
-const LANGUAGES = [
-  'zh',
-  'es',
-  'hi',
-  'ar',
-  'pt',
-  'ru',
-  'ja',
-  'de',
-  'fr',
-  'ko',
-  'ur',
-  'id',
-  'bn',
-  'tl',
-  'vi',
-  'it',
-];
+// Locale config (shared with audit.js)
+const { limits: LOCALE_LIMITS, languages: LANGUAGES } = require('../config/locales.js');
 
 // Paths
 const localesDir = path.join(process.cwd(), 'src', '_locales');
@@ -80,7 +63,7 @@ async function translate(complete) {
   // Check which languages need translation
   const languagesToTranslate = [];
 
-  for (const lang of LANGUAGES) {
+  for (const lang of Object.keys(LANGUAGES)) {
     const langDir = path.join(localesDir, lang);
     const langMessagesPath = path.join(langDir, 'messages.json');
 
@@ -156,21 +139,30 @@ async function translate(complete) {
 async function translateAllWithClaude(enMessages, languagesToTranslate) {
   // Build language info for prompt
   const languageList = languagesToTranslate.map(({ lang }) =>
-    `- "${lang}": ${getLanguageName(lang)}`
+    `- "${lang}": ${LANGUAGES[lang]}`
   ).join('\n');
 
+  // Build character limits info
+  const limitsInfo = Object.entries(LOCALE_LIMITS)
+    .map(([field, limit]) => `- ${field}: max ${limit} characters`)
+    .join('\n');
+
   const prompt = `Translate the following Chrome extension messages.json content from English to multiple languages.
 
 TARGET LANGUAGES:
 ${languageList}
 
+CHARACTER LIMITS (Chrome Web Store requirements):
+${limitsInfo}
+
 IMPORTANT RULES:
 1. Only translate the "message" field values
 2. Keep the "description" field values in English (they are for developers)
 3. Keep all JSON keys exactly as they are
 4. Return ONLY valid JSON, no markdown, no explanation
 5. Preserve any placeholders like $1, $2, etc.
-6. Return a JSON object where each key is the language code and the value is the translated messages object
+6. IMPORTANT: Respect the character limits above for each field
+7. Return a JSON object where each key is the language code and the value is the translated messages object
 
 INPUT (English):
 ${JSON.stringify(enMessages, null, 2)}
@@ -225,29 +217,5 @@ Output the translated JSON:`;
   }
 }
 
-// Get full language name
-function getLanguageName(code) {
-  const names = {
-    zh: 'Chinese (Simplified)',
-    es: 'Spanish',
-    hi: 'Hindi',
-    ar: 'Arabic',
-    pt: 'Portuguese',
-    ru: 'Russian',
-    ja: 'Japanese',
-    de: 'German',
-    fr: 'French',
-    ko: 'Korean',
-    ur: 'Urdu',
-    id: 'Indonesian',
-    bn: 'Bengali',
-    tl: 'Tagalog/Filipino',
-    vi: 'Vietnamese',
-    it: 'Italian',
-  };
-
-  return names[code] || code;
-}
-
 // Export task
 module.exports = series(translate);

package/dist/gulp/templates/BUILD_INSTRUCTIONS.md

@@ -25,8 +25,9 @@ npm install
 ```sh
 npm run build
 ```
-5. The built extension will be in `packaged/raw/` directory
-6. The packaged zip will be at `packaged/extension.zip`
+5. The built extensions will be in `packaged/` directory:
+   - **Firefox:** `packaged/firefox/raw/` (unpacked) and `packaged/firefox/extension.zip`
+   - **Chrome/Edge:** `packaged/chromium/raw/` (unpacked) and `packaged/chromium/extension.zip`
 
 ## Loading the Extension
 
@@ -34,13 +35,19 @@ npm run build
 1. Go to `about:debugging`
 2. Click "This Firefox"
 3. Click "Load Temporary Add-on"
-4. Select `packaged/raw/manifest.json`
+4. Select `packaged/firefox/raw/manifest.json`
 
 ### Chrome
 1. Go to `chrome://extensions`
 2. Enable "Developer mode"
 3. Click "Load unpacked"
-4. Select the `packaged/raw/` directory
+4. Select the `packaged/chromium/raw/` directory
+
+### Edge
+1. Go to `edge://extensions`
+2. Enable "Developer mode"
+3. Click "Load unpacked"
+4. Select the `packaged/chromium/raw/` directory
 
 ## Questions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-extension-manager",
-  "version": "1.2.12",
+  "version": "1.2.14",
   "description": "Browser Extension Manager dependency manager",
   "main": "dist/index.js",
   "exports": {