Add support for posting comment on closure (#99)

* allow ordering of issue lookup

__tests__/main.test.ts

@@ -35,6 +35,8 @@ const DefaultProcessorOptions: IssueProcessorOptions = {
   repoToken: 'none',
   staleIssueMessage: 'This issue is stale',
   stalePrMessage: 'This PR is stale',
+  closeIssueMessage: 'This issue is being closed',
+  closePrMessage: 'This PR is being closed',
   daysBeforeStale: 1,
   daysBeforeClose: 30,
   staleIssueLabel: 'Stale',
@@ -44,7 +46,8 @@ const DefaultProcessorOptions: IssueProcessorOptions = {
   onlyLabels: '',
   operationsPerRun: 100,
   debugOnly: true,
-  removeStaleWhenUpdated: false
+  removeStaleWhenUpdated: false,
+  ascending: false
 };
 
 test('empty issue list results in 1 operation', async () => {
@@ -62,11 +65,36 @@ test('empty issue list results in 1 operation', async () => {
   expect(operationsLeft).toEqual(99);
 });
 
-test('processing an issue with no label will make it stale and close it, if it is old enough', async () => {
+test('processing an issue with no label will make it stale and close it, if it is old enough only if days-before-close is set to 0', async () => {
   const TestIssueList: Issue[] = [
     generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z')
   ];
 
+  const opts = {...DefaultProcessorOptions};
+  opts.daysBeforeClose = 0;
+
+  const processor = new IssueProcessor(
+    opts,
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.staleIssues.length).toEqual(1);
+  expect(processor.closedIssues.length).toEqual(1);
+});
+
+test('processing an issue with no label will make it stale and not close it if days-before-close is set to > 0', async () => {
+  const TestIssueList: Issue[] = [
+    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z')
+  ];
+
+  const opts = {...DefaultProcessorOptions};
+  opts.daysBeforeClose = 15;
+
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
     async p => (p == 1 ? TestIssueList : []),
@@ -78,7 +106,7 @@ test('processing an issue with no label will make it stale and close it, if it i
   await processor.processIssues(1);
 
   expect(processor.staleIssues.length).toEqual(1);
-  expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.closedIssues.length).toEqual(0);
 });
 
 test('processing an issue with no label will make it stale but not close it', async () => {
@@ -426,6 +454,7 @@ test('exempt issue labels will not be marked stale (multi issue label)', async (
 
   expect(processor.staleIssues.length).toEqual(0);
   expect(processor.closedIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(0);
 });
 
 test('exempt pr labels will not be marked stale', async () => {
@@ -474,6 +503,7 @@ test('stale issues should not be closed if days is set to -1', async () => {
   await processor.processIssues(1);
 
   expect(processor.closedIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(0);
 });
 
 test('stale label should be removed if a comment was added to a stale issue', async () => {
@@ -493,7 +523,7 @@ test('stale label should be removed if a comment was added to a stale issue', as
   const processor = new IssueProcessor(
     opts,
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [{user: {type: 'User'}}], // return a fake comment so indicate there was an update
+    async (num, dt) => [{user: {login: 'notme', type: 'User'}}], // return a fake comment to indicate there was an update
     async (issue, label) => new Date().toDateString()
   );
 
@@ -504,3 +534,127 @@ test('stale label should be removed if a comment was added to a stale issue', as
   expect(processor.staleIssues.length).toEqual(0);
   expect(processor.removedLabelIssues.length).toEqual(1);
 });
+
+test('stale label should not be removed if a comment was added by the bot (and the issue should be closed)', async () => {
+  github.context.actor = 'abot';
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should stay stale',
+      '2020-01-01T17:00:00Z',
+      false,
+      ['Stale']
+    )
+  ];
+
+  const opts = DefaultProcessorOptions;
+  opts.removeStaleWhenUpdated = true;
+
+  const processor = new IssueProcessor(
+    opts,
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [{user: {login: 'abot', type: 'User'}}], // return a fake comment to indicate there was an update by the bot
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+});
+
+test('stale issues should not be closed until after the closed number of days', async () => {
+  let lastUpdate = new Date();
+  lastUpdate.setDate(lastUpdate.getDate() - 5);
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should be marked stale but not closed',
+      lastUpdate.toString(),
+      false
+    )
+  ];
+
+  const opts = DefaultProcessorOptions;
+  opts.daysBeforeStale = 5; // stale after 5 days
+  opts.daysBeforeClose = 1; // closes after 6 days
+
+  const processor = new IssueProcessor(
+    opts,
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(1);
+});
+
+test('stale issues should be closed if the closed nubmer of days (additive) is also passed', async () => {
+  let lastUpdate = new Date();
+  lastUpdate.setDate(lastUpdate.getDate() - 7);
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should be stale and closed',
+      lastUpdate.toString(),
+      false,
+      ['Stale']
+    )
+  ];
+
+  const opts = DefaultProcessorOptions;
+  opts.daysBeforeStale = 5; // stale after 5 days
+  opts.daysBeforeClose = 1; // closes after 6 days
+
+  const processor = new IssueProcessor(
+    opts,
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(0);
+});
+
+test('stale issues should not be closed until after the closed number of days (long)', async () => {
+  let lastUpdate = new Date();
+  lastUpdate.setDate(lastUpdate.getDate() - 10);
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should be marked stale but not closed',
+      lastUpdate.toString(),
+      false
+    )
+  ];
+
+  const opts = DefaultProcessorOptions;
+  opts.daysBeforeStale = 5; // stale after 5 days
+  opts.daysBeforeClose = 20; // closes after 25 days
+
+  const processor = new IssueProcessor(
+    opts,
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(1);
+});

action.yml

@@ -9,6 +9,10 @@ inputs:
     description: 'The message to post on the issue when tagging it. If none provided, will not mark issues stale.'
   stale-pr-message:
     description: 'The message to post on the pr when tagging it. If none provided, will not mark pull requests stale.'
+  close-issue-message:
+    description: 'The message to post on the issue when closing it. If none provided, will not comment when closing an issue.'
+  close-pr-message:
+    description: 'The message to post on the pr when closing it. If none provided, will not comment when closing a pull requests.'
   days-before-stale:
     description: 'The number of days old an issue can be before marking it stale.'
     default: 60
@@ -39,6 +43,9 @@ inputs:
   debug-only:
     description: 'Run the processor in debug mode without actually performing any operations on live issues.'
     default: false
+  ascending:
+    description: 'The order to get issues or pull requests. Defaults to false, which is descending'
+    default: false
 runs:
   using: 'node12'
   main: 'dist/index.js'

dist/index.js

@@ -3536,6 +3536,8 @@ function getAndValidateArgs() {
         repoToken: core.getInput('repo-token', { required: true }),
         staleIssueMessage: core.getInput('stale-issue-message'),
         stalePrMessage: core.getInput('stale-pr-message'),
+        closeIssueMessage: core.getInput('close-issue-message'),
+        closePrMessage: core.getInput('close-pr-message'),
         daysBeforeStale: parseInt(core.getInput('days-before-stale', { required: true })),
         daysBeforeClose: parseInt(core.getInput('days-before-close', { required: true })),
         staleIssueLabel: core.getInput('stale-issue-label', { required: true }),
@@ -3545,7 +3547,8 @@ function getAndValidateArgs() {
         onlyLabels: core.getInput('only-labels'),
         operationsPerRun: parseInt(core.getInput('operations-per-run', { required: true })),
         removeStaleWhenUpdated: !(core.getInput('remove-stale-when-updated') === 'false'),
-        debugOnly: core.getInput('debug-only') === 'true'
+        debugOnly: core.getInput('debug-only') === 'true',
+        ascending: core.getInput('ascending') === 'true'
     };
     for (const numberInput of [
         'days-before-stale',
@@ -3596,7 +3599,7 @@ exports.getUserAgent = getUserAgent;
 /***/ 215:
 /***/ (function(module) {
 
-module.exports = {"_args":[["@octokit/rest@16.43.1","/Users/pjquirk/Source/GitHub/pjquirk/stale"]],"_from":"@octokit/rest@16.43.1","_id":"@octokit/rest@16.43.1","_inBundle":false,"_integrity":"sha512-gfFKwRT/wFxq5qlNjnW2dh+qh74XgTQ2B179UX5K1HYCluioWj8Ndbgqw2PVqa1NnVJkGHp2ovMpVn/DImlmkw==","_location":"/@octokit/rest","_phantomChildren":{"@octokit/types":"2.8.2","deprecation":"2.3.1","once":"1.4.0"},"_requested":{"type":"version","registry":true,"raw":"@octokit/rest@16.43.1","name":"@octokit/rest","escapedName":"@octokit%2frest","scope":"@octokit","rawSpec":"16.43.1","saveSpec":null,"fetchSpec":"16.43.1"},"_requiredBy":["/","/@actions/github"],"_resolved":"https://registry.npmjs.org/@octokit/rest/-/rest-16.43.1.tgz","_spec":"16.43.1","_where":"/Users/pjquirk/Source/GitHub/pjquirk/stale","author":{"name":"Gregor Martynus","url":"https://github.com/gr2m"},"bugs":{"url":"https://github.com/octokit/rest.js/issues"},"bundlesize":[{"path":"./dist/octokit-rest.min.js.gz","maxSize":"33 kB"}],"contributors":[{"name":"Mike de Boer","email":"info@mikedeboer.nl"},{"name":"Fabian Jakobs","email":"fabian@c9.io"},{"name":"Joe Gallo","email":"joe@brassafrax.com"},{"name":"Gregor Martynus","url":"https://github.com/gr2m"}],"dependencies":{"@octokit/auth-token":"^2.4.0","@octokit/plugin-paginate-rest":"^1.1.1","@octokit/plugin-request-log":"^1.0.0","@octokit/plugin-rest-endpoint-methods":"2.4.0","@octokit/request":"^5.2.0","@octokit/request-error":"^1.0.2","atob-lite":"^2.0.0","before-after-hook":"^2.0.0","btoa-lite":"^1.0.0","deprecation":"^2.0.0","lodash.get":"^4.4.2","lodash.set":"^4.3.2","lodash.uniq":"^4.5.0","octokit-pagination-methods":"^1.1.0","once":"^1.4.0","universal-user-agent":"^4.0.0"},"description":"GitHub REST API client for Node.js","devDependencies":{"@gimenete/type-writer":"^0.1.3","@octokit/auth":"^1.1.1","@octokit/fixtures-server":"^5.0.6","@octokit/graphql":"^4.2.0","@types/node":"^13.1.0","bundlesize":"^0.18.0","chai":"^4.1.2","compression-webpack-plugin":"^3.1.0","cypress":"^3.0.0","glob":"^7.1.2","http-proxy-agent":"^4.0.0","lodash.camelcase":"^4.3.0","lodash.merge":"^4.6.1","lodash.upperfirst":"^4.3.1","lolex":"^5.1.2","mkdirp":"^1.0.0","mocha":"^7.0.1","mustache":"^4.0.0","nock":"^11.3.3","npm-run-all":"^4.1.2","nyc":"^15.0.0","prettier":"^1.14.2","proxy":"^1.0.0","semantic-release":"^17.0.0","sinon":"^8.0.0","sinon-chai":"^3.0.0","sort-keys":"^4.0.0","string-to-arraybuffer":"^1.0.0","string-to-jsdoc-comment":"^1.0.0","typescript":"^3.3.1","webpack":"^4.0.0","webpack-bundle-analyzer":"^3.0.0","webpack-cli":"^3.0.0"},"files":["index.js","index.d.ts","lib","plugins"],"homepage":"https://github.com/octokit/rest.js#readme","keywords":["octokit","github","rest","api-client"],"license":"MIT","name":"@octokit/rest","nyc":{"ignore":["test"]},"publishConfig":{"access":"public"},"release":{"publish":["@semantic-release/npm",{"path":"@semantic-release/github","assets":["dist/*","!dist/*.map.gz"]}]},"repository":{"type":"git","url":"git+https://github.com/octokit/rest.js.git"},"scripts":{"build":"npm-run-all build:*","build:browser":"npm-run-all build:browser:*","build:browser:development":"webpack --mode development --entry . --output-library=Octokit --output=./dist/octokit-rest.js --profile --json > dist/bundle-stats.json","build:browser:production":"webpack --mode production --entry . --plugin=compression-webpack-plugin --output-library=Octokit --output-path=./dist --output-filename=octokit-rest.min.js --devtool source-map","build:ts":"npm run -s update-endpoints:typescript","coverage":"nyc report --reporter=html && open coverage/index.html","generate-bundle-report":"webpack-bundle-analyzer dist/bundle-stats.json --mode=static --no-open --report dist/bundle-report.html","lint":"prettier --check '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","lint:fix":"prettier --write '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","postvalidate:ts":"tsc --noEmit --target es6 test/typescript-validate.ts","prebuild:browser":"mkdirp dist/","pretest":"npm run -s lint","prevalidate:ts":"npm run -s build:ts","start-fixtures-server":"octokit-fixtures-server","test":"nyc mocha test/mocha-node-setup.js \"test/*/**/*-test.js\"","test:browser":"cypress run --browser chrome","update-endpoints":"npm-run-all update-endpoints:*","update-endpoints:fetch-json":"node scripts/update-endpoints/fetch-json","update-endpoints:typescript":"node scripts/update-endpoints/typescript","validate:ts":"tsc --target es6 --noImplicitAny index.d.ts"},"types":"index.d.ts","version":"16.43.1"};
+module.exports = {"_args":[["@octokit/rest@16.43.1","/Users/owenvoke/projects/stale"]],"_from":"@octokit/rest@16.43.1","_id":"@octokit/rest@16.43.1","_inBundle":false,"_integrity":"sha512-gfFKwRT/wFxq5qlNjnW2dh+qh74XgTQ2B179UX5K1HYCluioWj8Ndbgqw2PVqa1NnVJkGHp2ovMpVn/DImlmkw==","_location":"/@octokit/rest","_phantomChildren":{"@octokit/types":"2.8.2","deprecation":"2.3.1","once":"1.4.0"},"_requested":{"type":"version","registry":true,"raw":"@octokit/rest@16.43.1","name":"@octokit/rest","escapedName":"@octokit%2frest","scope":"@octokit","rawSpec":"16.43.1","saveSpec":null,"fetchSpec":"16.43.1"},"_requiredBy":["/","/@actions/github"],"_resolved":"https://registry.npmjs.org/@octokit/rest/-/rest-16.43.1.tgz","_spec":"16.43.1","_where":"/Users/owenvoke/projects/stale","author":{"name":"Gregor Martynus","url":"https://github.com/gr2m"},"bugs":{"url":"https://github.com/octokit/rest.js/issues"},"bundlesize":[{"path":"./dist/octokit-rest.min.js.gz","maxSize":"33 kB"}],"contributors":[{"name":"Mike de Boer","email":"info@mikedeboer.nl"},{"name":"Fabian Jakobs","email":"fabian@c9.io"},{"name":"Joe Gallo","email":"joe@brassafrax.com"},{"name":"Gregor Martynus","url":"https://github.com/gr2m"}],"dependencies":{"@octokit/auth-token":"^2.4.0","@octokit/plugin-paginate-rest":"^1.1.1","@octokit/plugin-request-log":"^1.0.0","@octokit/plugin-rest-endpoint-methods":"2.4.0","@octokit/request":"^5.2.0","@octokit/request-error":"^1.0.2","atob-lite":"^2.0.0","before-after-hook":"^2.0.0","btoa-lite":"^1.0.0","deprecation":"^2.0.0","lodash.get":"^4.4.2","lodash.set":"^4.3.2","lodash.uniq":"^4.5.0","octokit-pagination-methods":"^1.1.0","once":"^1.4.0","universal-user-agent":"^4.0.0"},"description":"GitHub REST API client for Node.js","devDependencies":{"@gimenete/type-writer":"^0.1.3","@octokit/auth":"^1.1.1","@octokit/fixtures-server":"^5.0.6","@octokit/graphql":"^4.2.0","@types/node":"^13.1.0","bundlesize":"^0.18.0","chai":"^4.1.2","compression-webpack-plugin":"^3.1.0","cypress":"^3.0.0","glob":"^7.1.2","http-proxy-agent":"^4.0.0","lodash.camelcase":"^4.3.0","lodash.merge":"^4.6.1","lodash.upperfirst":"^4.3.1","lolex":"^5.1.2","mkdirp":"^1.0.0","mocha":"^7.0.1","mustache":"^4.0.0","nock":"^11.3.3","npm-run-all":"^4.1.2","nyc":"^15.0.0","prettier":"^1.14.2","proxy":"^1.0.0","semantic-release":"^17.0.0","sinon":"^8.0.0","sinon-chai":"^3.0.0","sort-keys":"^4.0.0","string-to-arraybuffer":"^1.0.0","string-to-jsdoc-comment":"^1.0.0","typescript":"^3.3.1","webpack":"^4.0.0","webpack-bundle-analyzer":"^3.0.0","webpack-cli":"^3.0.0"},"files":["index.js","index.d.ts","lib","plugins"],"homepage":"https://github.com/octokit/rest.js#readme","keywords":["octokit","github","rest","api-client"],"license":"MIT","name":"@octokit/rest","nyc":{"ignore":["test"]},"publishConfig":{"access":"public"},"release":{"publish":["@semantic-release/npm",{"path":"@semantic-release/github","assets":["dist/*","!dist/*.map.gz"]}]},"repository":{"type":"git","url":"git+https://github.com/octokit/rest.js.git"},"scripts":{"build":"npm-run-all build:*","build:browser":"npm-run-all build:browser:*","build:browser:development":"webpack --mode development --entry . --output-library=Octokit --output=./dist/octokit-rest.js --profile --json > dist/bundle-stats.json","build:browser:production":"webpack --mode production --entry . --plugin=compression-webpack-plugin --output-library=Octokit --output-path=./dist --output-filename=octokit-rest.min.js --devtool source-map","build:ts":"npm run -s update-endpoints:typescript","coverage":"nyc report --reporter=html && open coverage/index.html","generate-bundle-report":"webpack-bundle-analyzer dist/bundle-stats.json --mode=static --no-open --report dist/bundle-report.html","lint":"prettier --check '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","lint:fix":"prettier --write '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","postvalidate:ts":"tsc --noEmit --target es6 test/typescript-validate.ts","prebuild:browser":"mkdirp dist/","pretest":"npm run -s lint","prevalidate:ts":"npm run -s build:ts","start-fixtures-server":"octokit-fixtures-server","test":"nyc mocha test/mocha-node-setup.js \"test/*/**/*-test.js\"","test:browser":"cypress run --browser chrome","update-endpoints":"npm-run-all update-endpoints:*","update-endpoints:fetch-json":"node scripts/update-endpoints/fetch-json","update-endpoints:typescript":"node scripts/update-endpoints/typescript","validate:ts":"tsc --target es6 --noImplicitAny index.d.ts"},"types":"index.d.ts","version":"16.43.1"};
 
 /***/ }),
 
@@ -8649,197 +8652,250 @@ class IssueProcessor {
     }
     processIssues(page = 1) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.operationsLeft <= 0) {
-                core.warning('Reached max number of operations to process. Exiting.');
-                return 0;
-            }
             // get the next batch of issues
             const issues = yield this.getIssues(page);
             this.operationsLeft -= 1;
             if (issues.length <= 0) {
-                core.debug('No more issues found to process. Exiting.');
+                core.info('No more issues found to process. Exiting.');
                 return this.operationsLeft;
             }
             for (const issue of issues.values()) {
                 const isPr = !!issue.pull_request;
-                core.debug(`Found issue: issue #${issue.number} - ${issue.title} last updated ${issue.updated_at} (is pr? ${isPr})`);
+                core.info(`Found issue: issue #${issue.number} - ${issue.title} last updated ${issue.updated_at} (is pr? ${isPr})`);
                 // calculate string based messages for this issue
                 const staleMessage = isPr
                     ? this.options.stalePrMessage
                     : this.options.staleIssueMessage;
+                const closeMessage = isPr
+                    ? this.options.closePrMessage
+                    : this.options.closeIssueMessage;
                 const staleLabel = isPr
                     ? this.options.stalePrLabel
                     : this.options.staleIssueLabel;
                 const exemptLabels = IssueProcessor.parseCommaSeparatedString(isPr ? this.options.exemptPrLabels : this.options.exemptIssueLabels);
                 const issueType = isPr ? 'pr' : 'issue';
                 if (!staleMessage) {
-                    core.debug(`Skipping ${issueType} due to empty stale message`);
+                    core.info(`Skipping ${issueType} due to empty stale message`);
                     continue;
                 }
                 if (issue.state === 'closed') {
-                    core.debug(`Skipping ${issueType} because it is closed`);
+                    core.info(`Skipping ${issueType} because it is closed`);
                     continue; // don't process closed issues
                 }
                 if (issue.locked) {
-                    core.debug(`Skipping ${issueType} because it is locked`);
+                    core.info(`Skipping ${issueType} because it is locked`);
                     continue; // don't process locked issues
                 }
                 if (exemptLabels.some((exemptLabel) => IssueProcessor.isLabeled(issue, exemptLabel))) {
-                    core.debug(`Skipping ${issueType} because it has an exempt label`);
+                    core.info(`Skipping ${issueType} because it has an exempt label`);
                     continue; // don't process exempt issues
                 }
                 // does this issue have a stale label?
                 let isStale = IssueProcessor.isLabeled(issue, staleLabel);
+                // should this issue be marked stale?
+                const shouldBeStale = !IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeStale);
                 // determine if this issue needs to be marked stale first
-                if (!isStale &&
-                    !IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeStale)) {
-                    core.debug(`Marking ${issueType} stale because it was last updated on ${issue.updated_at} and it does not have a stale label`);
+                if (!isStale && shouldBeStale) {
+                    core.info(`Marking ${issueType} stale because it was last updated on ${issue.updated_at} and it does not have a stale label`);
                     yield this.markStale(issue, staleMessage, staleLabel);
-                    this.operationsLeft -= 2;
                     isStale = true; // this issue is now considered stale
                 }
-                // process any issues marked stale (including the issue above, if it was marked)
+                // process the issue if it was marked stale
                 if (isStale) {
-                    core.debug(`Found a stale ${issueType}`);
-                    yield this.processStaleIssue(issue, issueType, staleLabel);
+                    core.info(`Found a stale ${issueType}`);
+                    yield this.processStaleIssue(issue, issueType, staleLabel, closeMessage);
                 }
             }
+            if (this.operationsLeft <= 0) {
+                core.warning('Reached max number of operations to process. Exiting.');
+                return 0;
+            }
             // do the next batch
             return this.processIssues(page + 1);
         });
     }
     // handle all of the stale issue logic when we find a stale issue
-    processStaleIssue(issue, issueType, staleLabel) {
+    processStaleIssue(issue, issueType, staleLabel, closeMessage) {
         return __awaiter(this, void 0, void 0, function* () {
+            const markedStaleOn = (yield this.getLabelCreationDate(issue, staleLabel)) || issue.updated_at;
+            core.info(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
+            const issueHasComments = yield this.hasCommentsSince(issue, markedStaleOn);
+            core.info(`Issue #${issue.number} has been commented on: ${issueHasComments}`);
+            const issueHasUpdate = IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeClose);
+            core.info(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
+            // should we un-stale this issue?
+            if (this.options.removeStaleWhenUpdated && issueHasComments) {
+                core.info(`Issue #${issue.number} is no longer stale. Removing stale label.`);
+                yield this.removeLabel(issue, staleLabel);
+            }
+            // now start closing logic
             if (this.options.daysBeforeClose < 0) {
                 return; // nothing to do because we aren't closing stale issues
             }
-            const markedStaleOn = yield this.getLabelCreationDate(issue, staleLabel);
-            const issueHasComments = yield this.isIssueStillStale(issue, markedStaleOn || issue.updated_at);
-            const issueHasUpdate = IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeClose);
-            if (markedStaleOn) {
-                core.debug(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
-            }
-            else {
-                core.debug(`Issue #${issue.number} is not marked stale, but last update of ${issue.updated_at} is older than ${this.options.daysBeforeStale} days`);
-            }
-            core.debug(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
-            core.debug(`Issue #${issue.number} has been commented on: ${issueHasComments}`);
             if (!issueHasComments && !issueHasUpdate) {
-                core.debug(`Closing ${issueType} because it was last updated on ${issue.updated_at}`);
-                yield this.closeIssue(issue);
+                core.info(`Closing ${issueType} because it was last updated on ${issue.updated_at}`);
+                yield this.closeIssue(issue, closeMessage);
             }
             else {
-                if (this.options.removeStaleWhenUpdated) {
-                    yield this.removeLabel(issue, staleLabel);
-                }
-                core.debug(`Ignoring stale ${issueType} because it was updated recently`);
+                core.info(`Stale ${issueType} is not old enough to close yet (hasComments? ${issueHasComments}, hasUpdate? ${issueHasUpdate}`);
             }
         });
     }
     // checks to see if a given issue is still stale (has had activity on it)
-    isIssueStillStale(issue, sinceDate) {
+    hasCommentsSince(issue, sinceDate) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.debug(`Checking for comments on issue #${issue.number} since ${sinceDate} to see if it is still stale`);
+            core.info(`Checking for comments on issue #${issue.number} since ${sinceDate}`);
             if (!sinceDate) {
-                return true; // if no date was provided then the issue was marked stale a long time ago
+                return true;
             }
-            this.operationsLeft -= 1;
-            // find any comments since the stale label
+            // find any comments since the date
             const comments = yield this.listIssueComments(issue.number, sinceDate);
-            // if there are any user comments returned, issue is not stale anymore
-            return comments.filter(comment => comment.user.type === 'User').length > 0;
+            const filteredComments = comments.filter(comment => comment.user.type === 'User' &&
+                comment.user.login !== github.context.actor);
+            core.info(`Comments not made by ${github.context.actor} or another bot: ${filteredComments.length}`);
+            // if there are any user comments returned
+            return filteredComments.length > 0;
         });
     }
     // grab comments for an issue since a given date
     listIssueComments(issueNumber, sinceDate) {
         return __awaiter(this, void 0, void 0, function* () {
             // find any comments since date on the given issue
-            const comments = yield this.client.issues.listComments({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                issue_number: issueNumber,
-                since: sinceDate
-            });
-            return comments.data;
+            try {
+                const comments = yield this.client.issues.listComments({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    issue_number: issueNumber,
+                    since: sinceDate
+                });
+                return comments.data;
+            }
+            catch (error) {
+                core.error(`List issue comments error: ${error.message}`);
+                return Promise.resolve([]);
+            }
         });
     }
     // grab issues from github in baches of 100
     getIssues(page) {
         return __awaiter(this, void 0, void 0, function* () {
-            const issueResult = yield this.client.issues.listForRepo({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                state: 'open',
-                labels: this.options.onlyLabels,
-                per_page: 100,
-                page
-            });
-            return issueResult.data;
+            try {
+                const issueResult = yield this.client.issues.listForRepo({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    state: 'open',
+                    labels: this.options.onlyLabels,
+                    per_page: 100,
+                    direction: this.options.ascending ? 'asc' : 'desc',
+                    page
+                });
+                return issueResult.data;
+            }
+            catch (error) {
+                core.error(`Get issues for repo error: ${error.message}`);
+                return Promise.resolve([]);
+            }
         });
     }
     // Mark an issue as stale with a comment and a label
     markStale(issue, staleMessage, staleLabel) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.debug(`Marking issue #${issue.number} - ${issue.title} as stale`);
+            core.info(`Marking issue #${issue.number} - ${issue.title} as stale`);
             this.staleIssues.push(issue);
             this.operationsLeft -= 2;
+            // if the issue is being marked stale, the updated date should be changed to right now
+            // so that close calculations work correctly
+            const newUpdatedAtDate = new Date();
+            issue.updated_at = newUpdatedAtDate.toString();
             if (this.options.debugOnly) {
                 return;
             }
-            yield this.client.issues.createComment({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                issue_number: issue.number,
-                body: staleMessage
-            });
-            yield this.client.issues.addLabels({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                issue_number: issue.number,
-                labels: [staleLabel]
-            });
+            try {
+                yield this.client.issues.createComment({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    issue_number: issue.number,
+                    body: staleMessage
+                });
+            }
+            catch (error) {
+                core.error(`Error creating a comment: ${error.message}`);
+            }
+            try {
+                yield this.client.issues.addLabels({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    issue_number: issue.number,
+                    labels: [staleLabel]
+                });
+            }
+            catch (error) {
+                core.error(`Error adding a label: ${error.message}`);
+            }
         });
     }
     // Close an issue based on staleness
-    closeIssue(issue) {
+    closeIssue(issue, closeMessage) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.debug(`Closing issue #${issue.number} - ${issue.title} for being stale`);
+            core.info(`Closing issue #${issue.number} - ${issue.title} for being stale`);
             this.closedIssues.push(issue);
             this.operationsLeft -= 1;
             if (this.options.debugOnly) {
                 return;
             }
-            yield this.client.issues.update({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                issue_number: issue.number,
-                state: 'closed'
-            });
+            if (closeMessage) {
+                try {
+                    yield this.client.issues.createComment({
+                        owner: github.context.repo.owner,
+                        repo: github.context.repo.repo,
+                        issue_number: issue.number,
+                        body: closeMessage
+                    });
+                }
+                catch (error) {
+                    core.error(`Error creating a comment: ${error.message}`);
+                }
+            }
+            try {
+                yield this.client.issues.update({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    issue_number: issue.number,
+                    state: 'closed'
+                });
+            }
+            catch (error) {
+                core.error(`Error updating an issue: ${error.message}`);
+            }
         });
     }
     // Remove a label from an issue
     removeLabel(issue, label) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.debug(`Removing label ${label} from issue #${issue.number} - ${issue.title}`);
+            core.info(`Removing label ${label} from issue #${issue.number} - ${issue.title}`);
             this.removedLabelIssues.push(issue);
             this.operationsLeft -= 1;
             if (this.options.debugOnly) {
                 return;
             }
-            yield this.client.issues.removeLabel({
-                owner: github.context.repo.owner,
-                repo: github.context.repo.repo,
-                issue_number: issue.number,
-                name: encodeURIComponent(label) // A label can have a "?" in the name
-            });
+            try {
+                yield this.client.issues.removeLabel({
+                    owner: github.context.repo.owner,
+                    repo: github.context.repo.repo,
+                    issue_number: issue.number,
+                    name: encodeURIComponent(label) // A label can have a "?" in the name
+                });
+            }
+            catch (error) {
+                core.error(`Error removing a label: ${error.message}`);
+            }
         });
     }
     // returns the creation date of a given label on an issue (or nothing if no label existed)
     ///see https://developer.github.com/v3/activity/events/
     getLabelCreationDate(issue, label) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.debug(`Checking for label ${label} on issue #${issue.number}`);
+            core.info(`Checking for label ${label} on issue #${issue.number}`);
             this.operationsLeft -= 1;
             const options = this.client.issues.listEvents.endpoint.merge({
                 owner: github.context.repo.owner,
@@ -8864,7 +8920,7 @@ class IssueProcessor {
     static updatedSince(timestamp, num_days) {
         const daysInMillis = 1000 * 60 * 60 * 24 * num_days;
         const millisSinceLastUpdated = new Date().getTime() - new Date(timestamp).getTime();
-        return millisSinceLastUpdated < daysInMillis;
+        return millisSinceLastUpdated <= daysInMillis;
     }
     static parseCommaSeparatedString(s) {
         // String.prototype.split defaults to [''] when called on an empty string

src/IssueProcessor.ts

@@ -16,6 +16,7 @@ export interface Issue {
 
 export interface User {
   type: string;
+  login: string;
 }
 
 export interface Comment {
@@ -36,6 +37,8 @@ export interface IssueProcessorOptions {
   repoToken: string;
   staleIssueMessage: string;
   stalePrMessage: string;
+  closeIssueMessage: string;
+  closePrMessage: string;
   daysBeforeStale: number;
   daysBeforeClose: number;
   staleIssueLabel: string;
@@ -46,6 +49,7 @@ export interface IssueProcessorOptions {
   operationsPerRun: number;
   removeStaleWhenUpdated: boolean;
   debugOnly: boolean;
+  ascending: boolean;
 }
 
 /***
@@ -67,7 +71,10 @@ export class IssueProcessor {
       issueNumber: number,
       sinceDate: string
     ) => Promise<Comment[]>,
-    getLabelCreationDate?: (issue: Issue, label: string) => Promise<string | undefined>
+    getLabelCreationDate?: (
+      issue: Issue,
+      label: string
+    ) => Promise<string | undefined>
   ) {
     this.options = options;
     this.operationsLeft = options.operationsPerRun;
@@ -93,24 +100,19 @@ export class IssueProcessor {
   }
 
   async processIssues(page: number = 1): Promise<number> {
-    if (this.operationsLeft <= 0) {
-      core.warning('Reached max number of operations to process. Exiting.');
-      return 0;
-    }
-
     // get the next batch of issues
     const issues: Issue[] = await this.getIssues(page);
     this.operationsLeft -= 1;
 
     if (issues.length <= 0) {
-      core.debug('No more issues found to process. Exiting.');
+      core.info('No more issues found to process. Exiting.');
       return this.operationsLeft;
     }
 
     for (const issue of issues.values()) {
       const isPr = !!issue.pull_request;
 
-      core.debug(
+      core.info(
         `Found issue: issue #${issue.number} - ${issue.title} last updated ${issue.updated_at} (is pr? ${isPr})`
       );
 
@@ -118,6 +120,9 @@ export class IssueProcessor {
       const staleMessage: string = isPr
         ? this.options.stalePrMessage
         : this.options.staleIssueMessage;
+      const closeMessage: string = isPr
+        ? this.options.closePrMessage
+        : this.options.closeIssueMessage;
       const staleLabel: string = isPr
         ? this.options.stalePrLabel
         : this.options.staleIssueLabel;
@@ -127,17 +132,17 @@ export class IssueProcessor {
       const issueType: string = isPr ? 'pr' : 'issue';
 
       if (!staleMessage) {
-        core.debug(`Skipping ${issueType} due to empty stale message`);
+        core.info(`Skipping ${issueType} due to empty stale message`);
         continue;
       }
 
       if (issue.state === 'closed') {
-        core.debug(`Skipping ${issueType} because it is closed`);
+        core.info(`Skipping ${issueType} because it is closed`);
         continue; // don't process closed issues
       }
 
       if (issue.locked) {
-        core.debug(`Skipping ${issueType} because it is locked`);
+        core.info(`Skipping ${issueType} because it is locked`);
         continue; // don't process locked issues
       }
 
@@ -146,36 +151,45 @@ export class IssueProcessor {
           IssueProcessor.isLabeled(issue, exemptLabel)
         )
       ) {
-        core.debug(`Skipping ${issueType} because it has an exempt label`);
+        core.info(`Skipping ${issueType} because it has an exempt label`);
         continue; // don't process exempt issues
       }
 
       // does this issue have a stale label?
       let isStale = IssueProcessor.isLabeled(issue, staleLabel);
 
+      // should this issue be marked stale?
+      const shouldBeStale = !IssueProcessor.updatedSince(
+        issue.updated_at,
+        this.options.daysBeforeStale
+      );
+
       // determine if this issue needs to be marked stale first
-      if (
-        !isStale &&
-        !IssueProcessor.updatedSince(
-          issue.updated_at,
-          this.options.daysBeforeStale
-        )
-      ) {
-        core.debug(
+      if (!isStale && shouldBeStale) {
+        core.info(
           `Marking ${issueType} stale because it was last updated on ${issue.updated_at} and it does not have a stale label`
         );
         await this.markStale(issue, staleMessage, staleLabel);
-        this.operationsLeft -= 2;
         isStale = true; // this issue is now considered stale
       }
 
-      // process any issues marked stale (including the issue above, if it was marked)
+      // process the issue if it was marked stale
       if (isStale) {
-        core.debug(`Found a stale ${issueType}`);
-        await this.processStaleIssue(issue, issueType, staleLabel);
+        core.info(`Found a stale ${issueType}`);
+        await this.processStaleIssue(
+          issue,
+          issueType,
+          staleLabel,
+          closeMessage
+        );
       }
     }
 
+    if (this.operationsLeft <= 0) {
+      core.warning('Reached max number of operations to process. Exiting.');
+      return 0;
+    }
+
     // do the next batch
     return this.processIssues(page + 1);
   }
@@ -184,67 +198,80 @@ export class IssueProcessor {
   private async processStaleIssue(
     issue: Issue,
     issueType: string,
-    staleLabel: string
+    staleLabel: string,
+    closeMessage?: string
   ) {
-    if (this.options.daysBeforeClose < 0) {
-      return; // nothing to do because we aren't closing stale issues
-    }
+    const markedStaleOn: string =
+      (await this.getLabelCreationDate(issue, staleLabel)) || issue.updated_at;
+    core.info(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
 
-    const markedStaleOn: string | undefined = await this.getLabelCreationDate(
+    const issueHasComments: boolean = await this.hasCommentsSince(
       issue,
-      staleLabel
+      markedStaleOn
     );
-    const issueHasComments: boolean = await this.isIssueStillStale(
-      issue,
-      markedStaleOn || issue.updated_at
+    core.info(
+      `Issue #${issue.number} has been commented on: ${issueHasComments}`
     );
+
     const issueHasUpdate: boolean = IssueProcessor.updatedSince(
       issue.updated_at,
       this.options.daysBeforeClose
     );
+    core.info(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
 
-    if (markedStaleOn) {
-      core.debug(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
+    // should we un-stale this issue?
+    if (this.options.removeStaleWhenUpdated && issueHasComments) {
+      core.info(
+        `Issue #${issue.number} is no longer stale. Removing stale label.`
+      );
+      await this.removeLabel(issue, staleLabel);
     }
-    else {
-      core.debug(`Issue #${issue.number} is not marked stale, but last update of ${issue.updated_at} is older than ${this.options.daysBeforeStale} days`);
+
+    // now start closing logic
+    if (this.options.daysBeforeClose < 0) {
+      return; // nothing to do because we aren't closing stale issues
     }
-    core.debug(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
-    core.debug(`Issue #${issue.number} has been commented on: ${issueHasComments}`);
 
     if (!issueHasComments && !issueHasUpdate) {
-      core.debug(
+      core.info(
         `Closing ${issueType} because it was last updated on ${issue.updated_at}`
       );
-      await this.closeIssue(issue);
+      await this.closeIssue(issue, closeMessage);
     } else {
-      if (this.options.removeStaleWhenUpdated) {
-        await this.removeLabel(issue, staleLabel);
-      }
-      core.debug(`Ignoring stale ${issueType} because it was updated recently`);
+      core.info(
+        `Stale ${issueType} is not old enough to close yet (hasComments? ${issueHasComments}, hasUpdate? ${issueHasUpdate}`
+      );
     }
   }
 
   // checks to see if a given issue is still stale (has had activity on it)
-  private async isIssueStillStale(
+  private async hasCommentsSince(
     issue: Issue,
     sinceDate: string
   ): Promise<boolean> {
-    core.debug(
-      `Checking for comments on issue #${issue.number} since ${sinceDate} to see if it is still stale`
+    core.info(
+      `Checking for comments on issue #${issue.number} since ${sinceDate}`
     );
 
     if (!sinceDate) {
-      return true; // if no date was provided then the issue was marked stale a long time ago
+      return true;
     }
 
-    this.operationsLeft -= 1;
-
-    // find any comments since the stale label
+    // find any comments since the date
     const comments = await this.listIssueComments(issue.number, sinceDate);
 
-    // if there are any user comments returned, issue is not stale anymore
-    return comments.filter(comment => comment.user.type === 'User').length > 0;
+    const filteredComments = comments.filter(
+      comment =>
+        comment.user.type === 'User' &&
+        comment.user.login !== github.context.actor
+    );
+
+    core.info(
+      `Comments not made by ${github.context.actor} or another bot: ${filteredComments.length}`
+    );
+
+    // if there are any user comments returned
+    return filteredComments.length > 0;
   }
 
   // grab comments for an issue since a given date
@@ -253,28 +280,39 @@ export class IssueProcessor {
     sinceDate: string
   ): Promise<Comment[]> {
     // find any comments since date on the given issue
-    const comments = await this.client.issues.listComments({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      issue_number: issueNumber,
-      since: sinceDate
-    });
-
-    return comments.data;
+    try {
+      const comments = await this.client.issues.listComments({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        issue_number: issueNumber,
+        since: sinceDate
+      });
+      return comments.data;
+    } catch (error) {
+      core.error(`List issue comments error: ${error.message}`);
+      return Promise.resolve([]);
+    }
   }
 
   // grab issues from github in baches of 100
   private async getIssues(page: number): Promise<Issue[]> {
-    const issueResult: OctoKitIssueList = await this.client.issues.listForRepo({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      state: 'open',
-      labels: this.options.onlyLabels,
-      per_page: 100,
-      page
-    });
-
-    return issueResult.data;
+    try {
+      const issueResult: OctoKitIssueList = await this.client.issues.listForRepo(
+        {
+          owner: github.context.repo.owner,
+          repo: github.context.repo.repo,
+          state: 'open',
+          labels: this.options.onlyLabels,
+          per_page: 100,
+          direction: this.options.ascending ? 'asc' : 'desc',
+          page
+        }
+      );
+      return issueResult.data;
+    } catch (error) {
+      core.error(`Get issues for repo error: ${error.message}`);
+      return Promise.resolve([]);
+    }
   }
 
   // Mark an issue as stale with a comment and a label
@@ -283,34 +321,47 @@ export class IssueProcessor {
     staleMessage: string,
     staleLabel: string
   ): Promise<void> {
-    core.debug(`Marking issue #${issue.number} - ${issue.title} as stale`);
+    core.info(`Marking issue #${issue.number} - ${issue.title} as stale`);
 
     this.staleIssues.push(issue);
 
     this.operationsLeft -= 2;
 
+    // if the issue is being marked stale, the updated date should be changed to right now
+    // so that close calculations work correctly
+    const newUpdatedAtDate: Date = new Date();
+    issue.updated_at = newUpdatedAtDate.toString();
+
     if (this.options.debugOnly) {
       return;
     }
 
-    await this.client.issues.createComment({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      issue_number: issue.number,
-      body: staleMessage
-    });
+    try {
+      await this.client.issues.createComment({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        issue_number: issue.number,
+        body: staleMessage
+      });
+    } catch (error) {
+      core.error(`Error creating a comment: ${error.message}`);
+    }
 
-    await this.client.issues.addLabels({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      issue_number: issue.number,
-      labels: [staleLabel]
-    });
+    try {
+      await this.client.issues.addLabels({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        issue_number: issue.number,
+        labels: [staleLabel]
+      });
+    } catch (error) {
+      core.error(`Error adding a label: ${error.message}`);
+    }
   }
 
   // Close an issue based on staleness
-  private async closeIssue(issue: Issue): Promise<void> {
-    core.debug(
+  private async closeIssue(issue: Issue, closeMessage?: string): Promise<void> {
+    core.info(
       `Closing issue #${issue.number} - ${issue.title} for being stale`
     );
 
@@ -322,17 +373,34 @@ export class IssueProcessor {
       return;
     }
 
-    await this.client.issues.update({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      issue_number: issue.number,
-      state: 'closed'
-    });
+    if (closeMessage) {
+      try {
+        await this.client.issues.createComment({
+          owner: github.context.repo.owner,
+          repo: github.context.repo.repo,
+          issue_number: issue.number,
+          body: closeMessage
+        });
+      } catch (error) {
+        core.error(`Error creating a comment: ${error.message}`);
+      }
+    }
+
+    try {
+      await this.client.issues.update({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        issue_number: issue.number,
+        state: 'closed'
+      });
+    } catch (error) {
+      core.error(`Error updating an issue: ${error.message}`);
+    }
   }
 
   // Remove a label from an issue
   private async removeLabel(issue: Issue, label: string): Promise<void> {
-    core.debug(
+    core.info(
       `Removing label ${label} from issue #${issue.number} - ${issue.title}`
     );
 
@@ -344,12 +412,16 @@ export class IssueProcessor {
       return;
     }
 
-    await this.client.issues.removeLabel({
-      owner: github.context.repo.owner,
-      repo: github.context.repo.repo,
-      issue_number: issue.number,
-      name: encodeURIComponent(label) // A label can have a "?" in the name
-    });
+    try {
+      await this.client.issues.removeLabel({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        issue_number: issue.number,
+        name: encodeURIComponent(label) // A label can have a "?" in the name
+      });
+    } catch (error) {
+      core.error(`Error removing a label: ${error.message}`);
+    }
   }
 
   // returns the creation date of a given label on an issue (or nothing if no label existed)
@@ -358,7 +430,7 @@ export class IssueProcessor {
     issue: Issue,
     label: string
   ): Promise<string | undefined> {
-    core.debug(`Checking for label ${label} on issue #${issue.number}`);
+    core.info(`Checking for label ${label} on issue #${issue.number}`);
 
     this.operationsLeft -= 1;
 
@@ -395,7 +467,7 @@ export class IssueProcessor {
     const millisSinceLastUpdated =
       new Date().getTime() - new Date(timestamp).getTime();
 
-    return millisSinceLastUpdated < daysInMillis;
+    return millisSinceLastUpdated <= daysInMillis;
   }
 
   private static parseCommaSeparatedString(s: string): string[] {

src/main.ts

@@ -18,6 +18,8 @@ function getAndValidateArgs(): IssueProcessorOptions {
     repoToken: core.getInput('repo-token', {required: true}),
     staleIssueMessage: core.getInput('stale-issue-message'),
     stalePrMessage: core.getInput('stale-pr-message'),
+    closeIssueMessage: core.getInput('close-issue-message'),
+    closePrMessage: core.getInput('close-pr-message'),
     daysBeforeStale: parseInt(
       core.getInput('days-before-stale', {required: true})
     ),
@@ -35,7 +37,8 @@ function getAndValidateArgs(): IssueProcessorOptions {
     removeStaleWhenUpdated: !(
       core.getInput('remove-stale-when-updated') === 'false'
     ),
-    debugOnly: core.getInput('debug-only') === 'true'
+    debugOnly: core.getInput('debug-only') === 'true',
+    ascending: core.getInput('ascending') === 'true'
   };
 
   for (const numberInput of [