{
  "manifest_version": 3,
  "name": "My Thunderbird Extension",
  "version": "1.0.0",
  "description": "Extension description",
  "author": "Your Name",
  "browser_specific_settings": {
    "gecko": {
      "id": "extension@example.com",
      "strict_min_version": "128.0"
    }
  },
  "icons": {
    "16": "icons/icon-16.png",
    "32": "icons/icon-32.png",
    "64": "icons/icon-64.png"
  },
  "background": {
    "service_worker": "background.js",
    "type": "module"
  },
  "action": {
    "default_popup": "popup.html",
    "default_title": "My Extension",
    "default_icon": "icons/icon-32.png"
  },
  "permissions": [
    "storage",
    "messagesRead",
    "addressBooks"
  ]
}

{
  "manifest_version": 2,
  "name": "My Thunderbird Extension",
  "version": "1.0.0",
  "author": "Your Name",
  "browser_specific_settings": {
    "gecko": {
      "id": "extension@example.com",
      "strict_min_version": "128.0"
    }
  },
  "background": {
    "scripts": ["background.js"],
    "type": "module"
  },
  "browser_action": {
    "default_popup": "popup.html",
    "default_title": "My Extension"
  },
  "permissions": [
    "storage",
    "messagesRead",
    "addressBooks"
  ]
}

// List all accounts
const accounts = await messenger.accounts.list();
// Get specific account
const account = await messenger.accounts.get(accountId);
// Get account details
console.log(account.name, account.type, account.identities);
// List folders in account
const folders = await messenger.folders.getSubFolders(account);

// List messages in folder
const messages = await messenger.messages.list(folderId);
// Get specific message
const message = await messenger.messages.get(messageId);
// Message properties
console.log(message.subject, message.from, message.to, message.date);
// Get full message with body
const fullMessage = await messenger.messages.getFull(messageId);
console.log(fullMessage.parts[0].body);
// Query messages
const results = await messenger.messages.query({
  from: "sender@example.com",
  unread: true,
  limit: 50
});
// Move messages
await messenger.messages.move([messageId], destinationFolderId);
// Copy messages
await messenger.messages.copy([messageId], destinationFolderId);
// Delete messages
await messenger.messages.delete([messageId], true); // true = skip trash
// Mark as read/unread
await messenger.messages.update(messageId, { read: true });
// Archive messages
await messenger.messages.archive([messageId]);
// Import message
const importedId = await messenger.messages.import(
  file,  // File object
  folderId,
  { read: true, flagged: false }
);

// Get folder
const folder = await messenger.folders.get(folderId);
// List subfolders
const subfolders = await messenger.folders.getSubFolders(parentFolder);
// Create folder
const newFolder = await messenger.folders.create(parentAccountId, "New Folder");
// Rename folder
await messenger.folders.rename(folderId, "New Name");
// Delete folder
await messenger.folders.delete(folderId);
// Mark folder as read
await messenger.folders.markAsRead(folderId);
// Get folder properties
console.log(folder.name, folder.path, folder.unreadCount, folder.totalCount);

// List address books
const addressBooks = await messenger.addressBooks.list();
// Get address book
const book = await messenger.addressBooks.get(addressBookId);
// Create contact (vCard format)
const contactId = await messenger.addressBooks.contacts.create(addressBookId, {
  vCard: `BEGIN:VCARD
VERSION:4.0
FN:John Doe
EMAIL:john@example.com
TEL:+1-555-0100
END:VCARD`
});
// Get contact
const contact = await messenger.addressBooks.contacts.get(contactId);
console.log(contact.vCard);
// Update contact
await messenger.addressBooks.contacts.update(contactId, {
  vCard: updatedVCard
});
// Delete contact
await messenger.addressBooks.contacts.delete(contactId);
// Quick search contacts
const results = await messenger.addressBooks.contacts.quickSearch("john");
// Search in specific address book
const results = await messenger.addressBooks.contacts.query({
  addressBookId: addressBookId,
  searchText: "john"
});
// Create mailing list
const listId = await messenger.addressBooks.mailingLists.create(addressBookId, {
  name: "Team",
  nickName: "team",
  description: "Team members"
});
// Add contact to mailing list
await messenger.addressBooks.mailingLists.addMember(listId, contactId);

// Open compose window
const tab = await messenger.compose.beginNew({
  to: ["recipient@example.com"],
  cc: ["cc@example.com"],
  subject: "Hello",
  body: "Message content",
  isPlainText: false
});
// Compose with attachments
await messenger.compose.beginNew({
  to: ["recipient@example.com"],
  attachments: [{
    file: new File(["content"], "file.txt", { type: "text/plain" })
  }]
});
// Reply to message
await messenger.compose.beginReply(messageId, "replyToAll");
// Forward message
await messenger.compose.beginForward(messageId, "forwardInline");
// Get compose details
const details = await messenger.compose.getComposeDetails(tabId);
console.log(details.to, details.subject, details.body);
// Set compose details
await messenger.compose.setComposeDetails(tabId, {
  subject: "Updated Subject"
});
// Listen for compose events
messenger.compose.onBeforeSend.addListener((tab, details) => {
  // Modify message before sending
  details.body += "\n\n-- Sent via MyExtension";
  return { details };
});
// Listen for compose window open
messenger.compose.onComposeCreated.addListener((tab) => {
  console.log("Compose window created:", tab.id);
});

// Listen for message displayed
messenger.messageDisplay.onMessageDisplayed.addListener((tab, message) => {
  console.log("Message displayed:", message.subject);
});
// Get displayed message
const message = await messenger.messageDisplay.getDisplayedMessage(tabId);
// Listen for messages displayed (batch)
messenger.messageDisplay.onMessagesDisplayed.addListener((tab, messages) => {
  console.log(`${messages.length} messages displayed`);
});

// Get current mail tab
const mailTab = await messenger.mailTabs.getCurrent();
// Get displayed folder
const folder = await messenger.mailTabs.getDisplayedFolder(tabId);
// Set displayed folder
await messenger.mailTabs.update(tabId, {
  displayedFolderId: folderId
});
// Get selected messages
const selection = await messenger.mailTabs.getSelectedMessages(tabId);
// Listen for folder changes
messenger.mailTabs.onSelectedMessagesChanged.addListener((tab, selection) => {
  console.log("Selection changed:", selection.messages);
});

{
  "action": {
    "default_popup": "popup.html",
    "default_title": "My Extension",
    "default_icon": {
      "16": "icons/icon-16.png",
      "32": "icons/icon-32.png"
    }
  }
}

// Listen for clicks (if no popup)
messenger.action.onClicked.addListener((tab) => {
  console.log("Action clicked");
});
// Update badge
await messenger.action.setBadgeText({ text: "5" });
await messenger.action.setBadgeBackgroundColor({ color: "#ff0000" });
// Update icon
await messenger.action.setIcon({ path: "icons/icon-active.png" });

{
  "compose_action": {
    "default_popup": "compose_popup.html",
    "default_title": "Compose Tool",
    "default_icon": "icons/compose-icon.png"
  }
}

// Listen for clicks in compose window
messenger.composeAction.onClicked.addListener((tab) => {
  const details = await messenger.compose.getComposeDetails(tab.id);
  console.log("Compose action clicked:", details.subject);
});

{
  "message_display_action": {
    "default_popup": "message_popup.html",
    "default_title": "Message Tool",
    "default_icon": "icons/message-icon.png"
  }
}

// Listen for clicks on message
messenger.messageDisplayAction.onClicked.addListener(async (tab) => {
  const message = await messenger.messageDisplay.getDisplayedMessage(tab.id);
  console.log("Message action clicked:", message.subject);
});

{
  "message_display_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["message_content.js"],
      "css": ["message_styles.css"]
    }
  ]
}

// In background.js
await messenger.scripting.messageDisplay.executeScript({
  tabId: tabId,
  files: ["message_content.js"]
});

// message_content.js
// Send message to background
const response = await messenger.runtime.sendMessage({
  action: "processMessage",
  content: document.body.innerText
});
// Listen for messages from background
messenger.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.action === "highlight") {
    // Highlight text in message
    document.body.innerHTML = document.body.innerHTML.replace(
      message.text,
      `<mark>${message.text}</mark>`
    );
  }
});

{
  "experiment_apis": {
    "myapi": {
      "schema": "api/myapi/schema.json",
      "parent": {
        "scopes": ["addon_parent"],
        "paths": [["myapi"]],
        "script": "api/myapi/implementation.js",
        "events": ["startup"]
      }
    }
  }
}

[
  {
    "namespace": "myapi",
    "functions": [
      {
        "name": "doSomething",
        "type": "function",
        "async": true,
        "parameters": [
          {
            "name": "param",
            "type": "string"
          }
        ]
      }
    ],
    "events": [
      {
        "name": "onSomething",
        "type": "function"
      }
    ]
  }
]

class MyAPI extends ExtensionAPI {
  getAPI(context) {
    return {
      myapi: {
        async doSomething(param) {
          // Access Thunderbird internals via Services
          const { Services } = ChromeUtils.import(
            "resource://gre/modules/Services.jsm"
          );
          
          // Do something with internal APIs
          return Services.someService.process(param);
        },
        onSomething: new ExtensionCommon.EventManager({
          context,
          name: "myapi.onSomething",
          register: (fire) => {
            const callback = (data) => fire.async(data);
            
            // Register with internal service
            someInternalService.addListener(callback);
            
            return () => {
              someInternalService.removeListener(callback);
            };
          }
        }).api()
      }
    };
  }
  onStartup() {
    console.log("Extension starting up");
  }
  onShutdown(reason) {
    console.log("Extension shutting down:", reason);
    // Cleanup required
    Services.obs.notifyObservers(null, "startupcache-invalidate", null);
  }
}

// In background.js
const result = await messenger.myapi.doSomething("param");
// Listen for experiment events
messenger.myapi.onSomething.addListener((data) => {
  console.log("Event received:", data);
});

# Privacy Policy for [Add-on Name]
 
## Data Collection
[Specific description of what data is collected]
 
## Purpose
[Why data is collected]
 
## Storage
[How and where data is stored]
 
## Sharing
[Whether data is shared with third parties]
 
## User Control
[How users can delete their data]

// Check manifest
messenger.runtime.getManifest();
// Check permissions
messenger.permissions.contains({ permissions: ['messagesRead'] });
// Get extension URL
messenger.runtime.getURL('/path/to/resource');
// Reload extension
messenger.runtime.reload();
// Check last error
if (messenger.runtime.lastError) {
  console.error(messenger.runtime.lastError);
}

# 1. Create extension
# 2. Load temporarily in Thunderbird
# 3. Test functionality
# 4. Check console for errors
# 5. Fix issues
# 6. Reload extension (click Reload in debug page)
# 7. Repeat until working
# 8. Build and submit to ATN

// Use console for debugging
console.log("Extension loaded");
console.log("Message received:", message);
// Structured logging
console.table([
  { id: 1, name: "First" },
  { id: 2, name: "Second" }
]);
// Timing
console.time("operation");
// ... operation
console.timeEnd("operation");

Components.utils.import("resource:///modules/mailServices.js");
MailServices.compose.OpenComposeWindow(...);

messenger.compose.beginNew({
  to: ["recipient@example.com"],
  subject: "Hello"
});

my-extension/
├── manifest.json
├── background.js
├── popup.html
├── popup.js
├── compose_popup.html
├── compose_popup.js
├── api/
│   └── myapi/
│       ├── schema.json
│       └── implementation.js
├── icons/
│   ├── icon-16.png
│   ├── icon-32.png
│   └── icon-64.png
├── _locales/
│   ├── en/
│   │   └── messages.json
│   └── it/
│       └── messages.json
└── README.md

async function safeAsync(fn) {
  try {
    return await fn();
  } catch (error) {
    console.error("Error:", error);
    return { error: error.message };
  }
}
// Usage
const result = await safeAsync(() => messenger.messages.get(messageId));
if (result.error) {
  console.error("Failed to get message:", result.error);
}

// Check Thunderbird version
const info = await messenger.runtime.getBrowserInfo();
console.log(info.version);
// Check platform info
const platform = await messenger.runtime.getPlatformInfo();
console.log(platform.os, platform.arch);
// List all listeners
// (Add logging to all addListener calls)
// Check storage
const all = await messenger.storage.local.get(null);
console.log("Stored data:", all);

my-thunderbird-extension/
├── manifest.json
├── background.js
├── popup.html
├── popup.js
├── compose_popup.html
├── compose_popup.js
├── message_popup.html
├── message_popup.js
├── message_content.js
├── styles/
│   └── popup.css
├── icons/
│   ├── icon-16.png
│   ├── icon-32.png
│   └── icon-64.png
├── api/
│   └── myapi/
│       ├── schema.json
│       └── implementation.js
├── _locales/
│   ├── en/
│   │   └── messages.json
│   └── it/
│       └── messages.json
└── README.md

{
  "permissions": [
    "storage",           // Data storage
    "messagesRead",      // Read messages
    "messagesMove",      // Move/copy/delete messages
    "addressBooks",      // Access contacts
    "compose",           // Compose windows
    "accountsRead",      // Read accounts
    "accountsFolders"    // Access folders
  ]
}

// Messages
messenger.messages.list(folderId)
messenger.messages.get(messageId)
messenger.messages.query({ from, unread })
messenger.messages.update(messageId, { read: true })
// Folders
messenger.folders.get(folderId)
messenger.folders.getSubFolders(account)
// Compose
messenger.compose.beginNew({ to, subject, body })
messenger.compose.getComposeDetails(tabId)
// Address Books
messenger.addressBooks.list()
messenger.addressBooks.contacts.create(addressBookId, { vCard })
// Display
messenger.messageDisplay.getDisplayedMessage(tabId)
messenger.messageDisplayAction.onClicked