Merge branch 'main' into mms2094-token-metadata-on-paste

Author: micaelae

.github/scripts/identify-codeowners.ts

@@ -0,0 +1,281 @@
+import * as core from '@actions/core';
+import { context, getOctokit } from '@actions/github';
+import { GitHub } from '@actions/github/lib/utils';
+import { retrievePullRequestFiles } from './shared/pull-request';
+import micromatch from 'micromatch';
+
+type TeamFiles = Record<string, string[]>;
+
+type TeamEmojis = {
+  [team: string]: string;
+}
+
+type CodeOwnerRule = {
+  pattern: string;
+  owners: string[];
+}
+
+// Team emoji mappings
+const teamEmojis: TeamEmojis = {
+  '@MetaMask/extension-devs': '🧩',
+  '@MetaMask/policy-reviewers': '📜',
+  '@MetaMask/supply-chain': '🔗',
+  '@MetaMask/snaps-devs': '🫰',
+  '@MetaMask/extension-security-team': '🔒',
+  '@MetaMask/extension-privacy-reviewers': '🕵️',
+  '@MetaMask/confirmations': '✅',
+  '@MetaMask/design-system-engineers': '🎨',
+  '@MetaMask/notifications': '🔔',
+  '@MetaMask/identity': '🪪',
+  '@MetaMask/accounts-engineers': '🔑',
+  '@MetaMask/swaps-engineers': '🔄',
+  '@MetaMask/ramp': '📈',
+  '@MetaMask/wallet-ux': '🖥️',
+  '@MetaMask/metamask-assets': '💎',
+};
+
+main().catch((error: Error): void => {
+  console.error(error);
+  process.exit(1);
+});
+
+async function main(): Promise<void> {
+  const PR_COMMENT_TOKEN = process.env.PR_COMMENT_TOKEN;
+  if (!PR_COMMENT_TOKEN) {
+    core.setFailed('PR_COMMENT_TOKEN not found');
+    process.exit(1);
+  }
+
+  // Initialise octokit, required to call Github API
+  const octokit: InstanceType<typeof GitHub> = getOctokit(PR_COMMENT_TOKEN);
+
+
+  const owner = context.repo.owner;
+  const repo = context.repo.repo;
+  const prNumber = context.payload.pull_request?.number;
+  if (!prNumber) {
+    core.setFailed('Pull request number not found');
+    process.exit(1);
+  }
+
+  // Get the changed files in the PR
+  const changedFiles = await retrievePullRequestFiles(octokit, owner, repo, prNumber);
+
+  // Read and parse the CODEOWNERS file
+  const codeownersContent = await getCodeownersContent(octokit, owner, repo);
+  const codeowners = parseCodeowners(codeownersContent);
+
+  // Match files to codeowners
+  const fileOwners = matchFilesToCodeowners(changedFiles, codeowners);
+
+  // Group files by team
+  const teamFiles = groupFilesByTeam(fileOwners);
+
+  // If no teams need to review, don't create or update comments
+  if (Object.keys(teamFiles).length === 0) {
+    console.log('No files requiring codeowner review, skipping comment');
+
+    // Check for existing bot comment and delete it if it exists
+    // (in case previous version of PR had files requiring review)
+    await deleteExistingComment(octokit, owner, repo, prNumber);
+    return;
+  }
+
+  // Create the comment body
+  const commentBody = createCommentBody(teamFiles, teamEmojis);
+
+  // Check for an existing comment and update or create as needed
+  await updateOrCreateComment(octokit, owner, repo, prNumber, commentBody);
+}
+
+async function getCodeownersContent(
+  octokit: InstanceType<typeof GitHub>,
+  owner: string,
+  repo: string
+): Promise<string> {
+  try {
+    const response = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: '.github/CODEOWNERS',
+      headers: {
+        'accept': 'application/vnd.github.raw',
+      },
+    });
+
+    if (response) {
+      return response.data as unknown as string;
+    }
+
+    throw new Error('Failed to get CODEOWNERS file content');
+  } catch (error) {
+    throw new Error(`Failed to get CODEOWNERS file: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function parseCodeowners(content: string): CodeOwnerRule[] {
+  return content
+    .split('\n')
+    .filter(line => line.trim() && !line.startsWith('#'))
+    .map(line => {
+      const [pattern, ...owners] = line.trim().split(/\s+/);
+      return { pattern, owners };
+    });
+}
+
+function matchFilesToCodeowners(files: string[], codeowners: CodeOwnerRule[]): Map<string, Set<string>> {
+  const fileOwners: Map<string, Set<string>> = new Map();
+
+  files.forEach(file => {
+    for (const { pattern, owners } of codeowners) {
+      if (isFileMatchingPattern(file, pattern)) {
+        // Not breaking here to allow for multiple patterns to match the same file
+        // i.e. if a directory is owned by one team, but specific files within that directory
+        // are also owned by another team, the file will be added to both teams
+        const ownerSet = fileOwners.get(file);
+        if (!ownerSet) {
+          fileOwners.set(file, new Set(owners));
+        } else {
+          owners.forEach((owner) => ownerSet.add(owner));
+        }
+      }
+    }
+  });
+
+  return fileOwners;
+}
+
+function isFileMatchingPattern(file: string, pattern: string): boolean {
+  // Case 1: Pattern explicitly ends with a slash (e.g., "docs/")
+  if (pattern.endsWith('/')) {
+    return micromatch.isMatch(file, `${pattern}**`);
+  }
+
+  // Case 2: Pattern doesn't end with a file extension - treat as directory
+  if (!pattern.match(/\.[^/]*$/)) {
+    // Treat as directory - match this path and everything under it
+    return micromatch.isMatch(file, `${pattern}/**`);
+  }
+
+  // Case 3: Pattern with file extension or already has wildcards
+  return micromatch.isMatch(file, pattern);
+}
+
+function groupFilesByTeam(fileOwners: Map<string, Set<string>>): TeamFiles {
+  const teamFiles: TeamFiles = {};
+
+  fileOwners.forEach((owners, file) => {
+    owners.forEach(owner => {
+      if (!teamFiles[owner]) {
+        teamFiles[owner] = [];
+      }
+      teamFiles[owner].push(file);
+    });
+  });
+
+  // Sort files within each team for consistent ordering
+  Object.values(teamFiles).forEach(files => files.sort());
+
+  return teamFiles;
+}
+
+function createCommentBody(teamFiles: TeamFiles, teamEmojis: TeamEmojis): string {
+  let commentBody = `<!-- METAMASK-CODEOWNERS-BOT -->\n✨ Files requiring CODEOWNER review ✨\n---\n`;
+
+  // Sort teams for consistent ordering
+  const allOwners = Object.keys(teamFiles);
+
+  const teamOwners = allOwners.filter(owner => owner.startsWith('@MetaMask/'));
+  const individualOwners = allOwners.filter(owner => !owner.startsWith('@MetaMask/'));
+
+  const sortFn = (a, b) => a.toLowerCase().localeCompare(b.toLowerCase());
+  const sortedTeamOwners = teamOwners.sort(sortFn);
+  const sortedIndividualOwners = individualOwners.sort(sortFn);
+
+  const sortedOwners= [...sortedTeamOwners, ...sortedIndividualOwners];
+
+  sortedOwners.forEach(team => {
+    const emoji = teamEmojis[team] || '👨‍🔧';
+    commentBody += `${emoji} ${team}\n`;
+    teamFiles[team].forEach(file => {
+      commentBody += `- \`${file}\`\n`;
+    });
+    commentBody += '\n';
+  });
+
+  return commentBody;
+}
+
+async function deleteExistingComment(
+  octokit: InstanceType<typeof GitHub>,
+  owner: string,
+  repo: string,
+  prNumber: number
+): Promise<void> {
+  // Get existing comments
+  const { data: comments } = await octokit.rest.issues.listComments({
+    owner,
+    repo,
+    issue_number: prNumber,
+  });
+
+  const botComment = comments.find(comment =>
+    comment.body?.includes('<!-- METAMASK-CODEOWNERS-BOT -->')
+  );
+
+  if (botComment) {
+    // Delete the existing comment
+    await octokit.rest.issues.deleteComment({
+      owner,
+      repo,
+      comment_id: botComment.id,
+    });
+
+    console.log('Deleted existing codeowners comment');
+  }
+}
+
+async function updateOrCreateComment(
+  octokit: InstanceType<typeof GitHub>,
+  owner: string,
+  repo: string,
+  prNumber: number,
+  commentBody: string
+): Promise<void> {
+  // Get existing comments
+  const { data: comments } = await octokit.rest.issues.listComments({
+    owner,
+    repo,
+    issue_number: prNumber,
+  });
+
+  const botComment = comments.find(comment =>
+    comment.body?.includes('<!-- METAMASK-CODEOWNERS-BOT -->')
+  );
+
+  if (botComment) {
+    // Simple text comparison is sufficient since we control both sides
+    if (botComment.body !== commentBody) {
+      await octokit.rest.issues.updateComment({
+        owner,
+        repo,
+        comment_id: botComment.id,
+        body: commentBody,
+      });
+
+      console.log('Updated existing codeowners comment');
+    } else {
+      console.log('No changes to codeowners, skipping comment update');
+    }
+  } else {
+    // Create new comment
+    await octokit.rest.issues.createComment({
+      owner,
+      repo,
+      issue_number: prNumber,
+      body: commentBody,
+    });
+
+    console.log('Created new codeowners comment');
+  }
+}

.github/scripts/shared/pull-request.ts

@@ -67,3 +67,26 @@ export async function retrievePullRequest(
 
   return pullRequest;
 }
+
+/**
+ * Retrieves files changed in a specific pull request
+ * @param octokit GitHub API client
+ * @param repoOwner Repository owner (e.g., "MetaMask")
+ * @param repoName Repository name (e.g., "metamask-extension")
+ * @param prNumber Pull request number
+ * @returns Array of filenames that were changed in the PR
+ */
+export async function retrievePullRequestFiles(
+  octokit: InstanceType<typeof GitHub>,
+  repoOwner: string,
+  repoName: string,
+  prNumber: number,
+): Promise<string[]> {
+  const response = await octokit.rest.pulls.listFiles({
+    owner: repoOwner,
+    repo: repoName,
+    pull_number: prNumber,
+  });
+
+  return response.data.map((file) => file.filename);
+}

.github/workflows/identify-codeowners.yml

@@ -0,0 +1,24 @@
+name: Identify Codeowners
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+
+jobs:
+  identify-codeowners:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout and setup environment
+        uses: MetaMask/action-checkout-and-setup@v1
+        with:
+          is-high-risk-environment: false
+          skip-allow-scripts: true
+
+      - name: Identify codeowners
+        env:
+          PR_COMMENT_TOKEN: ${{ secrets.PR_COMMENT_TOKEN }}
+        run: yarn tsx ./.github/scripts/identify-codeowners.ts

app/_locales/en/messages.json

@@ -431,6 +431,7 @@
       "unconnectedAccount": true
     },
     "featureFlags": {},
+    "remoteFeatureFlags": {},
     "networkConfigurationsByChainId": {
       "0x1": {
         "chainId": "0x1",