fix: Handle locked issue/PR reactions gracefully (#15967)

This commit fixes the add_reaction handlers to silently ignore failures
when attempting to add reactions to locked issues, PRs, or discussions.

Changes:
- Modified add_reaction.cjs to detect locked resource errors (403 with "locked" message)
- Modified add_reaction_and_edit_comment.cjs with the same fix
- Added tests for locked issue scenarios in both test files
- Tests verify that locked errors are logged but don't fail the workflow

Fixes #15966

Co-authored-by: Claude (Cloclo) <cloclo@github.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: 3 people

actions/setup/js/add_reaction.cjs

@@ -97,6 +97,23 @@ async function main() {
     await addReaction(reactionEndpoint, reaction);
   } catch (error) {
     const errorMessage = getErrorMessage(error);
+
+    // Check if the error is due to a locked issue/PR/discussion
+    // GitHub API returns 403 with specific messages for locked resources
+    const is403Error = error && typeof error === "object" && "status" in error && error.status === 403;
+    const hasLockedMessage = errorMessage && (
+      errorMessage.includes("locked") ||
+      errorMessage.includes("Lock conversation")
+    );
+
+    // Only ignore the error if it's a 403 AND mentions locked, or if the message mentions locked
+    if ((is403Error && hasLockedMessage) || (!is403Error && hasLockedMessage)) {
+      // Silently ignore locked resource errors - just log for debugging
+      core.info(`Cannot add reaction: resource is locked (this is expected and not an error)`);
+      return;
+    }
+
+    // For other errors, fail as before
     core.error(`Failed to add reaction: ${errorMessage}`);
     core.setFailed(`Failed to add reaction: ${errorMessage}`);
   }

actions/setup/js/add_reaction.test.cjs

@@ -389,6 +389,50 @@ describe("add_reaction", () => {
       expect(mockCore.error).toHaveBeenCalled();
       expect(mockCore.setFailed).toHaveBeenCalled();
     });
+
+    it("should silently ignore locked issue errors (status 403)", async () => {
+      const lockedError = new Error("Issue is locked");
+      lockedError.status = 403;
+      mockGithub.request.mockRejectedValueOnce(lockedError);
+
+      await runScript();
+
+      expect(mockCore.info).toHaveBeenCalledWith(expect.stringContaining("resource is locked"));
+      expect(mockCore.error).not.toHaveBeenCalled();
+      expect(mockCore.setFailed).not.toHaveBeenCalled();
+    });
+
+    it("should silently ignore locked issue errors (message contains 'locked')", async () => {
+      mockGithub.request.mockRejectedValueOnce(new Error("Lock conversation is enabled"));
+
+      await runScript();
+
+      expect(mockCore.info).toHaveBeenCalledWith(expect.stringContaining("resource is locked"));
+      expect(mockCore.error).not.toHaveBeenCalled();
+      expect(mockCore.setFailed).not.toHaveBeenCalled();
+    });
+
+    it("should fail for 403 errors that don't mention locked", async () => {
+      const forbiddenError = new Error("Forbidden: insufficient permissions");
+      forbiddenError.status = 403;
+      mockGithub.request.mockRejectedValueOnce(forbiddenError);
+
+      await runScript();
+
+      expect(mockCore.error).toHaveBeenCalledWith(expect.stringContaining("Failed to add reaction"));
+      expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining("Failed to add reaction"));
+    });
+
+    it("should fail for other non-403 errors", async () => {
+      const serverError = new Error("Internal server error");
+      serverError.status = 500;
+      mockGithub.request.mockRejectedValueOnce(serverError);
+
+      await runScript();
+
+      expect(mockCore.error).toHaveBeenCalledWith(expect.stringContaining("Failed to add reaction"));
+      expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining("Failed to add reaction"));
+    });
   });
 
   describe("output handling", () => {

actions/setup/js/add_reaction_and_edit_comment.cjs

@@ -155,6 +155,23 @@ async function main() {
     }
   } catch (error) {
     const errorMessage = getErrorMessage(error);
+
+    // Check if the error is due to a locked issue/PR/discussion
+    // GitHub API returns 403 with specific messages for locked resources
+    const is403Error = error && typeof error === "object" && "status" in error && error.status === 403;
+    const hasLockedMessage = errorMessage && (
+      errorMessage.includes("locked") ||
+      errorMessage.includes("Lock conversation")
+    );
+
+    // Only ignore the error if it's a 403 AND mentions locked, or if the message mentions locked
+    if ((is403Error && hasLockedMessage) || (!is403Error && hasLockedMessage)) {
+      // Silently ignore locked resource errors - just log for debugging
+      core.info(`Cannot add reaction: resource is locked (this is expected and not an error)`);
+      return;
+    }
+
+    // For other errors, fail as before
     core.error(`Failed to process reaction and comment creation: ${errorMessage}`);
     core.setFailed(`Failed to process reaction and comment creation: ${errorMessage}`);
   }

actions/setup/js/add_reaction_and_edit_comment.test.cjs

@@ -235,6 +235,50 @@ const mockCore = {
               (global.context.payload = { repository: { html_url: "https://github.com/testowner/testrepo" } }),
               await eval(`(async () => { ${reactionScript}; await main(); })()`),
               expect(mockCore.setFailed).toHaveBeenCalledWith("Unsupported event type: push"));
+          }),
+          it("should silently ignore locked issue errors (status 403)", async () => {
+            const lockedError = new Error("Issue is locked");
+            lockedError.status = 403;
+            ((process.env.GH_AW_REACTION = "eyes"),
+              (global.context.eventName = "issues"),
+              (global.context.payload = { issue: { number: 123 }, repository: { html_url: "https://github.com/testowner/testrepo" } }),
+              mockGithub.request.mockRejectedValueOnce(lockedError),
+              await eval(`(async () => { ${reactionScript}; await main(); })()`),
+              expect(mockCore.info).toHaveBeenCalledWith(expect.stringContaining("resource is locked")),
+              expect(mockCore.error).not.toHaveBeenCalled(),
+              expect(mockCore.setFailed).not.toHaveBeenCalled());
+          }),
+          it("should silently ignore locked issue errors (message contains 'locked')", async () => {
+            ((process.env.GH_AW_REACTION = "eyes"),
+              (global.context.eventName = "issues"),
+              (global.context.payload = { issue: { number: 123 }, repository: { html_url: "https://github.com/testowner/testrepo" } }),
+              mockGithub.request.mockRejectedValueOnce(new Error("Lock conversation is enabled")),
+              await eval(`(async () => { ${reactionScript}; await main(); })()`),
+              expect(mockCore.info).toHaveBeenCalledWith(expect.stringContaining("resource is locked")),
+              expect(mockCore.error).not.toHaveBeenCalled(),
+              expect(mockCore.setFailed).not.toHaveBeenCalled());
+          }),
+          it("should fail for 403 errors that don't mention locked", async () => {
+            const forbiddenError = new Error("Forbidden: insufficient permissions");
+            forbiddenError.status = 403;
+            ((process.env.GH_AW_REACTION = "eyes"),
+              (global.context.eventName = "issues"),
+              (global.context.payload = { issue: { number: 123 }, repository: { html_url: "https://github.com/testowner/testrepo" } }),
+              mockGithub.request.mockRejectedValueOnce(forbiddenError),
+              await eval(`(async () => { ${reactionScript}; await main(); })()`),
+              expect(mockCore.error).toHaveBeenCalledWith(expect.stringContaining("Failed to process reaction")),
+              expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining("Failed to process reaction")));
+          }),
+          it("should fail for other non-403 errors", async () => {
+            const serverError = new Error("Internal server error");
+            serverError.status = 500;
+            ((process.env.GH_AW_REACTION = "eyes"),
+              (global.context.eventName = "issues"),
+              (global.context.payload = { issue: { number: 123 }, repository: { html_url: "https://github.com/testowner/testrepo" } }),
+              mockGithub.request.mockRejectedValueOnce(serverError),
+              await eval(`(async () => { ${reactionScript}; await main(); })()`),
+              expect(mockCore.error).toHaveBeenCalledWith(expect.stringContaining("Failed to process reaction")),
+              expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining("Failed to process reaction")));
           }));
       }));
   }));