whose-turn 0.0.0-stage → 1.0.0-alpha.3

package/connectors/demo.mjs

@@ -0,0 +1,146 @@
+/** Demo connector: three invented projects with every state the rules know, timestamps relative to now, and a little life on later polls. No network. */
+import { toIsoUtc } from '../lib/text.mjs';
+
+export const id = 'demo';
+export const label = 'Demo';
+export const links = () => [{ label: 'Demo tracker', url: 'https://demo.example/' }];
+export const fields = [
+  { key: 'scenario', label: 'Scenario', hint: 'northwind, atlas or garden', required: true },
+  { key: 'part', label: 'Part', hint: 'tickets (the tracker side), code (PRs and asks), or empty for both' },
+];
+
+const HOUR = 3600000;
+let base = Date.now();
+const ago = (hours) => toIsoUtc(base - hours * HOUR);
+const SITE = 'https://demo.example/browse/';
+const REPO = 'https://github.com/example/';
+
+const ticket = (key, summary, status, category, assignee, hoursAgo, sinceHours, changedBy) => ({
+  key, summary, status, status_category: category, assignee, updated: ago(hoursAgo), url: `${SITE}${key}`,
+  status_change: sinceHours === undefined ? null : { since: ago(sinceHours), by: changedBy || assignee },
+});
+const comment = (id, key, hoursAgo, author, body) => ({ id, key, at: ago(hoursAgo), author, body, url: `${SITE}${key}?focusedCommentId=${id}` });
+const pr = (number, key, title, repo, overrides = {}) => ({
+  pr: number, key, title, base: 'main', state: 'OPEN', review: '', checks: 'passing', merged_at: '', updated_at: ago(5), url: `${REPO}${repo}/pull/${number}`,
+  last_comment_by: '', last_comment_at: '', last_comment_url: '', last_comment: '', unanswered: false, ...overrides,
+});
+const activity = (hoursAgo, number, key, kind, who, repo, text, body) => ({ at: ago(hoursAgo), pr: `${repo}#${number}`, key, kind, who, url: `${REPO}${repo}/pull/${number}`, text, body: body || text });
+const failedRun = (id, repo, workflow, hoursAgo, title) => ({
+  id, ref: `${repo}:${workflow}@main`, repo: `example/${repo}`, workflow, branch: 'main', failed: true, mine: true, actor: 'alex', title, url: `${REPO}${repo}/actions/runs/${id}`, at: ago(hoursAgo), streak: id,
+});
+const runActivity = (run) => ({ at: run.at, pr: run.ref, key: '', title: run.title, kind: 'check failed', who: run.workflow, url: run.url, text: `${run.workflow} on ${run.branch}`, body: '' });
+const ask = (noteId, repo, number, title, key, kind, who, hoursAgo, text) => ({ id: `gha:${noteId}`, repo: `example/${repo}`, number, ref: `${repo}#${number}`, title, key, kind, who, at: ago(hoursAgo), url: `${REPO}${repo}/pull/${number}`, text, body: text });
+
+const northwind = (polls) => {
+  const me = 'Alex Doe';
+  const tickets = [
+    ticket('NW-142', 'Rounds: due dates differ between locales', 'Passed', 'indeterminate', me, 1, 1, 'Sam Tester'),
+    ticket('NW-151', 'Export to CSV loses the header row on retry', 'In Progress', 'indeterminate', me, 3, 30),
+    ticket('NW-137', 'Login page: remember the last used organisation', polls >= 3 ? 'Ready for QA' : 'Code Review', 'indeterminate', polls >= 3 ? 'Sam Tester' : me, polls >= 3 ? 0.1 : 20, polls >= 3 ? 0.1 : 26, polls >= 3 ? me : undefined),
+    ticket('NW-171', 'Spike: search index on Postgres', 'In Progress', 'indeterminate', me, 9, 9),
+    ticket('NW-129', 'Audit log keeps the deleted user name', 'Ready for QA', 'indeterminate', 'Sam Tester', 30, 29, me),
+    ticket('NW-118', 'Nightly report email arrives twice', 'In QA', 'indeterminate', 'Sam Tester', 80, 79, me),
+    ticket('NW-104', 'Invoice PDF: wrong currency symbol for CHF', 'On Hold', 'indeterminate', me, 120, 118, 'Pat Owner'),
+    ticket('NW-160', 'Import wizard for legacy spreadsheets', 'Backlog', 'new', 'Unassigned', 200),
+    ticket('NW-099', 'Dashboard tiles: tooltip on hover', 'Done', 'done', me, 50),
+    ticket('NW-088', 'Rate limit on the search endpoint', 'Done', 'done', me, 140),
+  ];
+  const comments = [
+    comment('c1', 'NW-142', 1, 'Sam Tester', 'Have tested this on staging and it is now QA passed. Please also test it in the customer org once merged.'),
+    comment('c2', 'NW-151', 4, 'Pat Owner', `@${me} can you confirm the retry keeps the original delimiter? The client asked twice.`),
+    comment('c3', 'NW-151', 6, me, '@Pat Owner yes, the delimiter comes from the first attempt; adding a test for it.'),
+    comment('c4', 'NW-151', 2, 'Pat Owner', `@${me} and one more: does it cover TSV as well?`),
+    comment('c5', 'NW-104', 118, 'Pat Owner', 'On hold: waiting for the vendor to confirm the CHF rounding rule, they promised an answer next week.'),
+    comment('c6', 'NW-104', 140, me, 'Reproduced with the sample invoice, fix is a one-liner once we know the rule.'),
+    comment('c7', 'NW-118', 70, 'Sam Tester', `@${me} fyi, moved to In QA, will run the nightly job twice tonight.`),
+    comment('c8', 'NW-129', 28, 'Automation for Jira', 'Transitioned by rule "Ready for QA when PR approved".'),
+    ...(polls >= 3 ? [comment('c9', 'NW-137', 0.1, 'Sam Tester', `@${me} picked it up, first pass looks good, one question: should the choice survive logout?`)] : []),
+  ];
+  const prs = [
+    pr(3978, 'NW-142', 'NW-142 fix week start per locale', 'northwind-web', { base: 'release/2.5', review: 'APPROVED', updated_at: ago(2), last_comment_by: 'Chris Reviewer', last_comment_at: ago(3), last_comment: 'Nice find on the locale changing the week start.', last_comment_url: `${REPO}northwind-web/pull/3978#issuecomment-1` }),
+    pr(3991, 'NW-151', 'NW-151 keep the header row on CSV retry', 'northwind-web', { checks: 'failing', updated_at: ago(1) }),
+    pr(3985, 'NW-137', 'NW-137 remember the last organisation on login', 'northwind-web', { review: polls >= 3 ? 'APPROVED' : 'CHANGES_REQUESTED', updated_at: ago(polls >= 3 ? 0.2 : 19), last_comment_by: 'Chris Reviewer', last_comment_at: ago(19), last_comment: 'Please do not store the org id in localStorage without a namespace.', last_comment_url: `${REPO}northwind-web/pull/3985#discussion_r1`, unanswered: polls < 3 }),
+    pr(3960, 'NW-129', 'NW-129 keep the user name in the audit log', 'northwind-web', { state: 'MERGED', merged_at: ago(31), updated_at: ago(31) }),
+    pr(3940, 'NW-099', 'NW-099 dashboard tile tooltips', 'northwind-web', { state: 'MERGED', merged_at: ago(52), updated_at: ago(52) }),
+  ];
+  const acts = [
+    activity(1, 3991, 'NW-151', 'check failed', 'unit-tests', 'northwind-web', ''),
+    activity(3, 3978, 'NW-142', 'comment', 'Chris Reviewer', 'northwind-web', 'Nice find on the locale changing the week start.'),
+    activity(19, 3985, 'NW-137', 'changes requested', 'Chris Reviewer', 'northwind-web', 'Please do not store the org id in localStorage without a namespace.', 'Please do not store the org id in `localStorage` without a namespace.\n\nTwo tabs with two organisations would overwrite each other. A `nw:` prefix plus the user id is enough.'),
+    activity(31, 3960, 'NW-129', 'merged', '', 'northwind-web', ''),
+    activity(52, 3940, 'NW-099', 'merged', '', 'northwind-web', ''),
+    ...(polls >= 3 ? [activity(0.2, 3985, 'NW-137', 'approved', 'Chris Reviewer', 'northwind-web', 'Namespace added, looks good now.')] : []),
+  ];
+  const asks = [
+    ask('n1', 'northwind-api', 512, 'Paginate the audit endpoint', 'NW-133', 'review requested', 'Chris Reviewer', 7, 'Paginate the audit endpoint'),
+    ask('n2', 'northwind-infra', 77, 'Rotate the staging certificates', '', 'mentioned you', 'Pat Owner', 26, `@alex could you check whether the cron on staging still runs after the rotation?`),
+  ];
+  const runs = [failedRun(9001, 'northwind-web', 'scout-publish', 0.5, 'Merge pull request #3940 from example/nw-099-tooltips')];
+  return { me, tickets, comments, prs, activity: [...acts, ...runs.map(runActivity)], asks, runs };
+};
+
+const atlas = (polls) => {
+  const me = 'Alex Doe';
+  const tickets = [
+    ticket('ATL-77', 'Offline mode: queue edits made without network', 'In Review', 'indeterminate', me, 10, 12),
+    ticket('ATL-81', 'Crash on rotating the map while loading', 'Testing', 'indeterminate', 'Jo Qa', 40, 36, me),
+    ticket('ATL-64', 'Dark theme for the trip summary', 'Blocked', 'indeterminate', me, 90, 88, 'Dana Lead'),
+    ticket('ATL-85', 'Accessibility labels on the bottom bar', 'Todo', 'indeterminate', me, 5),
+    ticket('ATL-59', 'Share a trip as a link', 'Done', 'done', me, 100),
+    ticket('ATL-90', 'Replace the deprecated map SDK', 'Backlog', 'new', 'Dana Lead', 300),
+  ];
+  const comments = [
+    comment('a1', 'ATL-64', 88, 'Dana Lead', 'Blocked until design delivers the dark palette, see the Figma thread.'),
+    comment('a2', 'ATL-77', 9, 'Dana Lead', `@${me} please add a screenshot of the queue indicator to the PR description`),
+    comment('a3', 'ATL-81', 35, 'Jo Qa', 'Testing on the three devices now.'),
+    ...(polls >= 4 ? [comment('a4', 'ATL-81', 0.1, 'Jo Qa', `@${me} reproduced once more on the small device, log attached, can you have a look?`)] : []),
+  ];
+  const prs = [
+    pr(214, 'ATL-77', 'ATL-77 offline edit queue', 'atlas-mobile', { base: 'develop', updated_at: ago(9), last_comment_by: 'Dana Lead', last_comment_at: ago(9), last_comment: 'please add a screenshot of the queue indicator', last_comment_url: `${REPO}atlas-mobile/pull/214#issuecomment-3`, unanswered: true }),
+    pr(209, 'ATL-81', 'ATL-81 guard the map rotation during load', 'atlas-mobile', { base: 'develop', state: 'MERGED', merged_at: ago(41), updated_at: ago(41) }),
+    pr(198, 'ATL-59', 'ATL-59 share trip link', 'atlas-mobile', { base: 'develop', state: 'MERGED', merged_at: ago(101), updated_at: ago(101) }),
+  ];
+  const acts = [
+    activity(9, 214, 'ATL-77', 'comment', 'Dana Lead', 'atlas-mobile', 'please add a screenshot of the queue indicator'),
+    activity(41, 209, 'ATL-81', 'merged', '', 'atlas-mobile', ''),
+    activity(101, 198, 'ATL-59', 'merged', '', 'atlas-mobile', ''),
+  ];
+  return { me, tickets, comments, prs, activity: acts, asks: [] };
+};
+
+const garden = () => {
+  const me = 'alex';
+  const prs = [
+    pr(12, '', 'Water schedule: skip rainy days', 'garden-bot', { updated_at: ago(2), checks: 'running' }),
+    pr(11, '', 'Soil sensor calibration', 'garden-bot', { state: 'MERGED', merged_at: ago(30), updated_at: ago(30) }),
+    pr(9, '', 'Add the greenhouse zone', 'garden-bot', { state: 'MERGED', merged_at: ago(120), updated_at: ago(120) }),
+  ];
+  const acts = [
+    activity(2, 12, '', 'comment', 'you', 'garden-bot', 'Rebased on the sensor change.'),
+    activity(30, 11, '', 'merged', '', 'garden-bot', ''),
+    activity(120, 9, '', 'merged', '', 'garden-bot', ''),
+  ];
+  return { me, tickets: [], comments: [], prs, activity: acts, asks: [ask('g1', 'garden-bot', 13, 'Frost warning notifications', '', 'review requested', 'Sam Friend', 4, 'Frost warning notifications')] };
+};
+
+const SCENARIOS = { northwind, atlas, garden };
+
+export const poll = async ({ settings, cache }) => {
+  const scenario = SCENARIOS[settings.scenario];
+  if (!scenario) {
+    throw new Error(`Unknown demo scenario "${settings.scenario}"; use northwind, atlas or garden`);
+  }
+  cache.polls = (cache.polls || 0) + 1;
+  cache.base = cache.base || Date.now();
+  base = cache.base;
+  const scenarioData = scenario(cache.polls);
+  const titles = new Map(scenarioData.prs.map((entry) => [entry.url, entry.title]));
+  const data = { runs: [], ...scenarioData, activity: scenarioData.activity.map((item) => ({ ...item, title: item.title || titles.get(item.url) || '' })) };
+  if (settings.part === 'tickets') {
+    return { me: data.me, tickets: data.tickets, comments: data.comments, ticket_base: SITE, errors: {} };
+  }
+  if (settings.part === 'code') {
+    return { me: data.me, prs: data.prs, activity: data.activity, asks: data.asks, runs: data.runs, errors: {} };
+  }
+  return { ...data, ticket_base: SITE, errors: {} };
+};

package/connectors/github.mjs

@@ -0,0 +1,316 @@
+/** GitHub connector: your PRs in one repository with reviews, comments and checks, the workflow runs on its default branch, plus review requests and mentions across the org. Token from `GH_TOKEN`, else `gh auth token`. */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { RateLimited } from '../lib/http-client.mjs';
+import { oneline, nowIso, mapLimit, wordsRegex, DAY } from '../lib/text.mjs';
+import { cachedToken } from '../lib/token-cache.mjs';
+
+const run = promisify(execFile);
+const API = 'https://api.github.com';
+
+export const id = 'github';
+export const label = 'GitHub';
+export const links = (settings) => (settings.repo ? [{ label: 'GitHub', url: `https://github.com/${settings.repo}` }] : []);
+export const fields = [
+  { key: 'repo', label: 'Repository', hint: 'owner/name whose PRs are yours', required: true },
+  { key: 'org', label: 'Organisation', hint: 'notifications are kept only from this org; defaults to the repository owner' },
+  { key: 'me', label: 'Your login', hint: 'left empty, it is asked from the API once' },
+  { key: 'account', label: 'gh account', hint: 'which logged-in gh account to use' },
+  { key: 'bots', label: 'Bot logins', hint: 'comma-separated; their comments never count as a reply', list: true },
+  { key: 'workflow_runs', label: 'Workflow runs', hint: 'watch the Actions runs on the default branch; on unless set to false', boolean: true, default: true },
+];
+
+export const persistedCache = ['prs', 'asks', 'runStreaks'];
+
+/** `GH_TOKEN` when set (CI, a machine without gh), else the token gh holds. */
+const ghToken = (account, cache) => cachedToken(cache, async () => {
+  if (process.env.GH_TOKEN) {
+    return process.env.GH_TOKEN;
+  }
+  const { stdout } = await run('gh', account ? ['auth', 'token', '--user', account] : ['auth', 'token']);
+  return stdout.trim();
+});
+
+const createApi = (http, token) => (path) => {
+  const url = path.startsWith(API) ? path : `${API}${path}`;
+  if (!url.startsWith(`${API}/`)) {
+    throw new Error(`Refusing to send the GitHub token to ${url}`);
+  }
+  return http.fetchJson(url, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28' } });
+};
+
+const checksFor = async (api, repo, sha) => {
+  const runs = (await api(`/repos/${repo}/commits/${sha}/check-runs?per_page=100`)).check_runs || [];
+  const conclusions = runs.map((checkRun) => checkRun.conclusion || checkRun.status);
+  let state = 'passing';
+  if (conclusions.some((value) => ['failure', 'timed_out', 'cancelled', 'action_required'].includes(value))) {
+    state = 'failing';
+  } else if (conclusions.some((value) => ['queued', 'in_progress', 'pending', 'waiting', null, undefined].includes(value))) {
+    state = 'running';
+  } else if (!runs.length) {
+    state = 'none';
+  }
+  const failed = runs.filter((checkRun) => ['failure', 'timed_out'].includes(checkRun.conclusion));
+  return { state, failed };
+};
+
+const reviewDecision = (reviews) => {
+  const latest = {};
+  for (const review of reviews) {
+    if (['APPROVED', 'CHANGES_REQUESTED', 'DISMISSED'].includes(review.state)) {
+      latest[review.user.login] = review.state;
+    }
+  }
+  const values = new Set(Object.values(latest));
+  if (values.has('CHANGES_REQUESTED')) {
+    return 'CHANGES_REQUESTED';
+  }
+  return values.has('APPROVED') ? 'APPROVED' : '';
+};
+
+/** A PR's reference in the feed: the repository name and the number, so a PR without a ticket still says where it lives (RMA-167). */
+const prRef = (repo, number) => `${repo.split('/').pop()}#${number}`;
+
+const failedCheckActivity = (checkRun, { pr, key, title }) => ({ at: checkRun.completed_at || nowIso(), pr, key, title, kind: 'check failed', who: checkRun.name, url: checkRun.html_url, text: '', body: '' });
+
+const buildPr = async (api, { repo, me, bots, keyOf, sinceIso }, number) => {
+  const [pr, issueComments, inlineComments, reviews] = await Promise.all([
+    api(`/repos/${repo}/pulls/${number}`),
+    api(`/repos/${repo}/issues/${number}/comments?per_page=100`),
+    api(`/repos/${repo}/pulls/${number}/comments?per_page=100`),
+    api(`/repos/${repo}/pulls/${number}/reviews?per_page=100`),
+  ]);
+  const state = pr.merged_at ? 'MERGED' : pr.state.toUpperCase();
+  const checks = await checksFor(api, repo, pr.head.sha);
+  const human = [];
+  for (const comment of issueComments) {
+    human.push({ who: comment.user.login, at: comment.created_at, url: comment.html_url, kind: 'comment', body: comment.body || '', state: '' });
+  }
+  for (const comment of inlineComments) {
+    human.push({ who: comment.user.login, at: comment.created_at, url: comment.html_url, kind: 'inline comment', body: comment.body || '', state: '' });
+  }
+  for (const review of reviews) {
+    if (review.state === 'COMMENTED' && !review.body) {
+      continue;
+    }
+    human.push({ who: review.user.login, at: review.submitted_at || '', url: review.html_url, kind: review.state.toLowerCase().replace(/_/g, ' '), body: review.body || '', state: review.state });
+  }
+  const people = human.filter((item) => !bots.test(item.who) && item.at).sort((a, b) => a.at.localeCompare(b.at));
+  const others = people.filter((item) => item.who !== me);
+  const mine = people.filter((item) => item.who === me);
+  const last = others[others.length - 1];
+  const myLast = mine.length ? mine[mine.length - 1].at : '';
+  const key = keyOf(pr.title);
+  const subject = { pr: prRef(repo, number), key, title: pr.title };
+  const row = {
+    pr: number, key, title: pr.title, base: pr.base.ref, state, review: reviewDecision(reviews), checks: checks.state, merged_at: pr.merged_at || '',
+    updated_at: pr.updated_at, url: pr.html_url,
+    last_comment_by: last ? last.who : '', last_comment_at: last ? last.at : '', last_comment_url: last ? last.url : '', last_comment: last ? oneline(last.body, 160) : '',
+    unanswered: Boolean(last && state === 'OPEN' && last.state !== 'APPROVED' && last.at > myLast),
+  };
+  const activity = people.filter((item) => item.at >= sinceIso).map((item) => ({
+    ...subject, at: item.at, kind: item.kind, who: item.who === me ? 'you' : item.who, url: item.url, text: oneline(item.body), body: item.body.replace(/\r/g, '').slice(0, 6000),
+  }));
+  for (const checkRun of checks.failed) {
+    if ((checkRun.completed_at || '') >= sinceIso) {
+      activity.push(failedCheckActivity(checkRun, subject));
+    }
+  }
+  if (pr.merged_at && pr.merged_at >= sinceIso) {
+    activity.push({ ...subject, at: pr.merged_at, kind: 'merged', who: '', url: pr.html_url, text: '', body: '' });
+  }
+  return { row, activity, sha: pr.head.sha };
+};
+
+const refreshChecks = async (api, repo, cached, number) => {
+  const checks = await checksFor(api, repo, cached.sha);
+  if (checks.state === cached.row.checks) {
+    return;
+  }
+  cached.row.checks = checks.state;
+  for (const checkRun of checks.failed) {
+    const item = failedCheckActivity(checkRun, { pr: prRef(repo, number), key: cached.row.key, title: cached.row.title });
+    if (!cached.activity.some((existing) => existing.url === item.url && existing.at === item.at)) {
+      cached.activity.push(item);
+    }
+  }
+};
+
+const pollPrs = async (api, context) => {
+  const { repo, me, sinceIso, cache } = context;
+  const since = sinceIso.slice(0, 10);
+  const found = new Map();
+  const queries = [`repo:${repo} is:pr author:${me} is:open`, `repo:${repo} is:pr author:${me} updated:>=${since}`];
+  const searches = await Promise.all(queries.map((query) => api(`/search/issues?q=${encodeURIComponent(query)}&per_page=50`)));
+  for (const item of searches.flatMap((result) => result.items || [])) {
+    found.set(item.number, item.updated_at);
+  }
+  cache.prs = cache.prs || new Map();
+  const unchanged = [...found].filter(([number, updatedAt]) => cache.prs.get(number)?.updated_at === updatedAt).map(([number]) => number);
+  const changed = [...found].filter(([number]) => !unchanged.includes(number));
+  await mapLimit(unchanged.filter((number) => cache.prs.get(number).row.state === 'OPEN'), 4, (number) => refreshChecks(api, repo, cache.prs.get(number), number));
+  await mapLimit(changed, 4, async ([number, updatedAt]) => {
+    cache.prs.set(number, { updated_at: updatedAt, ...(await buildPr(api, context, number)) });
+  });
+  for (const number of [...cache.prs.keys()]) {
+    if (!found.has(number)) {
+      cache.prs.delete(number);
+    }
+  }
+  const prs = [...cache.prs.values()].map((entry) => entry.row).sort((a, b) => a.pr - b.pr);
+  const activity = [...cache.prs.values()].flatMap((entry) => entry.activity).filter((item) => item.at >= sinceIso).sort((a, b) => b.at.localeCompare(a.at));
+  return { prs, activity };
+};
+
+const RUN_FAILED = ['failure', 'timed_out', 'startup_failure'];
+const RUN_PASSED = ['success'];
+
+/** A workflow run's reference in the feed and the key of its row: repository name, workflow and branch (RMA-152). */
+const runRef = (repo, workflow, branch) => `${repo.split('/').pop()}:${workflow}@${branch}`;
+
+const defaultBranch = async (api, repo, cache) => {
+  if (!cache.defaultBranch || Date.now() - cache.defaultBranchAt > DAY) {
+    cache.defaultBranch = (await api(`/repos/${repo}`)).default_branch;
+    cache.defaultBranchAt = Date.now();
+  }
+  return cache.defaultBranch;
+};
+
+/** The completed runs on the default branch, newest first per workflow; pull request runs are left to the PR path. */
+const runsByWorkflow = (listed, branch) => {
+  const byWorkflow = new Map();
+  const decided = listed.filter((run) => run.head_branch === branch && !String(run.event).startsWith('pull_request') && !(run.pull_requests || []).length
+    && run.status === 'completed' && [...RUN_FAILED, ...RUN_PASSED].includes(run.conclusion));
+  for (const run of decided.sort((a, b) => b.created_at.localeCompare(a.created_at))) {
+    (byWorkflow.get(run.workflow_id) || byWorkflow.set(run.workflow_id, []).get(run.workflow_id)).push(run);
+  }
+  return byWorkflow;
+};
+
+/** The first failure of the newest unbroken failure streak; a streak longer than the page keeps the start seen on an earlier poll. */
+const streakStart = (runs, ref, cache) => {
+  const passedAt = runs.findIndex((run) => RUN_PASSED.includes(run.conclusion));
+  const failures = passedAt < 0 ? runs : runs.slice(0, passedAt);
+  const start = passedAt < 0 && cache.runStreaks.has(ref) ? cache.runStreaks.get(ref) : failures[failures.length - 1].id;
+  cache.runStreaks.set(ref, start);
+  return start;
+};
+
+const pollRuns = async (api, { repo, me, sinceIso, cache }) => {
+  const branch = await defaultBranch(api, repo, cache);
+  const listed = (await api(`/repos/${repo}/actions/runs?branch=${encodeURIComponent(branch)}&per_page=50`)).workflow_runs || [];
+  cache.runStreaks = cache.runStreaks || new Map();
+  const runs = [];
+  const activity = [];
+  for (const workflowRuns of runsByWorkflow(listed, branch).values()) {
+    const ref = runRef(repo, workflowRuns[0].name, branch);
+    workflowRuns.forEach((run, index) => {
+      const failed = RUN_FAILED.includes(run.conclusion);
+      const recovered = !failed && RUN_FAILED.includes(workflowRuns[index + 1]?.conclusion);
+      if ((failed || recovered) && run.updated_at >= sinceIso) {
+        activity.push({ at: run.updated_at, pr: ref, key: '', title: run.display_title || '', kind: failed ? 'check failed' : 'check passed', who: run.name, url: run.html_url, text: `${run.name} on ${branch}`, body: '' });
+      }
+    });
+    const latest = workflowRuns[0];
+    if (!RUN_FAILED.includes(latest.conclusion)) {
+      cache.runStreaks.delete(ref);
+      continue;
+    }
+    runs.push({
+      id: latest.id, ref, repo, workflow: latest.name, branch, failed: true, mine: [latest.actor?.login, latest.triggering_actor?.login].includes(me),
+      actor: latest.actor?.login || '', title: latest.display_title || '', url: latest.html_url, at: latest.updated_at, streak: streakStart(workflowRuns, ref, cache),
+    });
+  }
+  return { runs, activity };
+};
+
+const issueNumber = (apiUrl) => {
+  const match = /\/(pulls|issues)\/(\d+)$/.exec(apiUrl || '');
+  return match ? Number(match[2]) : null;
+};
+
+const buildAsk = async (api, { me, keyOf }, note, repo) => {
+  const subject = note.subject;
+  const number = issueNumber(subject.url);
+  if (!number) {
+    return null;
+  }
+  const title = subject.title || '';
+  const base = { repo, number, ref: prRef(repo, number), title, key: keyOf(title), url: `https://github.com/${repo}/${subject.type === 'PullRequest' ? 'pull' : 'issues'}/${number}` };
+  if (note.reason === 'review_requested' && subject.type === 'PullRequest') {
+    const pr = await api(`/repos/${repo}/pulls/${number}`);
+    if (pr.state !== 'open') {
+      return null;
+    }
+    const requested = await api(`/repos/${repo}/pulls/${number}/requested_reviewers`);
+    if (!(requested.users || []).some((user) => user.login === me)) {
+      return null;
+    }
+    return { ...base, id: `gha:${note.id}`, kind: 'review requested', who: pr.user.login, at: note.updated_at, text: oneline(title), body: (pr.body || '').slice(0, 6000) };
+  }
+  let comment = subject.latest_comment_url ? await api(subject.latest_comment_url) : null;
+  const comments = await api(`/repos/${repo}/issues/${number}/comments?per_page=100`);
+  if (!comment || !(comment.body || '').includes(`@${me}`)) {
+    const hits = comments.filter((candidate) => (candidate.body || '').includes(`@${me}`));
+    comment = hits.length ? hits[hits.length - 1] : comment;
+  }
+  if (!comment) {
+    return null;
+  }
+  const at = comment.created_at || note.updated_at;
+  if (comments.some((candidate) => candidate.user.login === me && candidate.created_at > at)) {
+    return null;
+  }
+  return { ...base, id: `gha:${note.id}`, kind: 'mentioned you', who: comment.user.login, at, url: comment.html_url || base.url, text: oneline(comment.body || ''), body: (comment.body || '').replace(/\r/g, '').slice(0, 6000) };
+};
+
+const pollAsks = async (api, context) => {
+  const { org, cache } = context;
+  const notes = await api('/notifications?participating=true&all=false&per_page=50');
+  cache.asks = cache.asks || new Map();
+  const rows = [];
+  const seen = new Set();
+  const relevant = notes.filter((note) => note.repository.full_name.startsWith(`${org}/`) && ['review_requested', 'mention', 'team_mention', 'assign'].includes(note.reason));
+  await mapLimit(relevant, 4, async (note) => {
+    seen.add(note.id);
+    const cached = cache.asks.get(note.id);
+    const row = cached && cached.updated_at === note.updated_at ? cached.row : await buildAsk(api, context, note, note.repository.full_name);
+    cache.asks.set(note.id, { updated_at: note.updated_at, row });
+    if (row) {
+      rows.push(row);
+    }
+  });
+  for (const noteId of [...cache.asks.keys()]) {
+    if (!seen.has(noteId)) {
+      cache.asks.delete(noteId);
+    }
+  }
+  return rows;
+};
+
+export const poll = async ({ settings, http, cache, sinceIso, keyOf }) => {
+  const api = createApi(http, await ghToken(settings.account, cache));
+  const me = settings.me || (cache.me ??= (await api('/user')).login);
+  const context = { repo: settings.repo, org: settings.org || settings.repo.split('/')[0], me, bots: wordsRegex(settings.bots || ['github-actions', 'dependabot', '[bot]']), keyOf, sinceIso, cache };
+  const watchRuns = settings.workflow_runs !== false;
+  const [prsOutcome, asksOutcome, runsOutcome] = await Promise.allSettled([pollPrs(api, context), pollAsks(api, context), watchRuns ? pollRuns(api, context) : { runs: [], activity: [] }]);
+  const errors = {};
+  for (const [part, outcome] of /** @type {[string, PromiseSettledResult<unknown>][]} */ ([['pulls', prsOutcome], ['notifications', asksOutcome], ['runs', runsOutcome]])) {
+    if (outcome.status === 'rejected') {
+      if (outcome.reason instanceof RateLimited) {
+        throw outcome.reason;
+      }
+      errors[part] = `${outcome.reason.name}: ${outcome.reason.message}`;
+    }
+  }
+  const last = cache.last || { prs: [], prActivity: [], asks: [], runs: [], runActivity: [] };
+  cache.last = {
+    prs: prsOutcome.status === 'fulfilled' ? prsOutcome.value.prs : last.prs,
+    prActivity: prsOutcome.status === 'fulfilled' ? prsOutcome.value.activity : last.prActivity,
+    asks: asksOutcome.status === 'fulfilled' ? asksOutcome.value : last.asks,
+    runs: runsOutcome.status === 'fulfilled' ? runsOutcome.value.runs : last.runs,
+    runActivity: runsOutcome.status === 'fulfilled' ? runsOutcome.value.activity : last.runActivity,
+  };
+  const { prs, prActivity, asks, runs, runActivity } = cache.last;
+  return { me, prs, asks, runs, activity: [...prActivity, ...runActivity].sort((a, b) => b.at.localeCompare(a.at)), errors };
+};

package/connectors/index.mjs

@@ -0,0 +1,38 @@
+/** The connector registry: every source type the server knows, and the catalogue the settings form and Claude read. */
+import * as github from './github.mjs';
+import * as jira from './jira.mjs';
+import * as demo from './demo.mjs';
+import * as linear from './linear.mjs';
+
+export const CONNECTORS = { github, jira, linear, demo };
+
+/** What a workspace calls each of its connectors: the entry's own label, else its id when another entry has the same type, else the type's label (RMA-167). */
+export const connectorSummaries = (entries) => entries.map((entry) => {
+  const shared = entries.some((other) => other !== entry && other.type === entry.type);
+  return { id: entry.id, type: entry.type, label: entry.label || (shared ? entry.id : CONNECTORS[entry.type]?.label || entry.type) };
+});
+
+export const connectorCatalogue = () => Object.values(CONNECTORS).map((connector) => ({ type: connector.id, label: connector.label, fields: connector.fields }));
+
+/** The triples a stored secret is bound to: every secret field's service and account plus the connector's endpoint. */
+const secretBindings = (entry) => (CONNECTORS[entry.type]?.fields || []).filter((field) => field.secret).map((field) => {
+  const target = secretTarget(entry, field.key);
+  return target ? { key: field.key, service: target.service, account: target.account, endpoint: String(entry[CONNECTORS[entry.type].endpointKey] || '') } : null;
+}).filter(Boolean);
+
+/** Secret fields of `entry` that must come with a fresh token because their service, account and endpoint triple is not already in the current config. */
+export const secretsRequired = (currentEntries, entry) => {
+  const known = new Set(currentEntries.flatMap(secretBindings).map((binding) => `${binding.service}\n${binding.account}\n${binding.endpoint}`));
+  return secretBindings(entry).filter((binding) => !known.has(`${binding.service}\n${binding.account}\n${binding.endpoint}`)).map((binding) => binding.key);
+};
+
+/** Resolves where a secret field of one connector entry is stored: the service and the account to file it under. */
+export const secretTarget = (entry, key) => {
+  const field = (CONNECTORS[entry.type]?.fields || []).find((candidate) => candidate.key === key && candidate.secret);
+  if (!field) {
+    return null;
+  }
+  const account = String(entry[field.secret.account] || '').trim();
+  const service = String(entry[field.secret.service] || field.secret.default || '').trim();
+  return account && service ? { service, account } : null;
+};