whose-turn 1.0.0-alpha.7 → 1.0.0-alpha.8

package/lib/api.mjs

@@ -4,9 +4,9 @@ import { join } from 'node:path';
 import { createStatic } from './static.mjs';
 import { ApiError, toApiError } from './errors.mjs';
 import { connectorCatalogue, secretTarget, secretsRequired } from '../connectors/index.mjs';
-import { entryShapeViolations, normaliseWorkspaces, WORKSPACE_FIELDS } from './config.mjs';
+import { desktopOf, entryShapeViolations, normaliseWorkspaces, WORKSPACE_FIELDS } from './config.mjs';
 import { FACTS } from './facts.mjs';
-import { createFeedback, isConfigured } from './feedback.mjs';
+import { createFeedback, installOf } from './feedback.mjs';
 import { composeIssue, DEFAULT_COMPOSER } from './compose.mjs';
 import { readSize, saveSize, checkMode, spawnOpener } from './window.mjs';
 import { frameHandOff } from './handoff.mjs';
@@ -109,9 +109,8 @@ const aggregateSummary = (workspaces) => {
 
 const OPEN_COOLDOWN_MS = 5000;
 
-export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig, secrets, inbox, http, reports, dataDir, opener = spawnOpener(appDir), updater = noUpdates(), changelog = null }) => {
+export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig, secrets, inbox, http, reports, dataDir, opener = spawnOpener(appDir), updater = noUpdates(), changelog = null, version = '' }) => {
   const windowFile = createStatic(join(appDir, 'dist'));
-  const feedbackCache = {};
   const pick = (id) => {
     const workspaces = registry.workspaces;
     if (!workspaces.length) {
@@ -164,14 +163,14 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
         return send(response, 200, { workspaces: [], problems: registry.problems, update: updater.status() });
       }
       const workspace = pick(url.searchParams.get('ws'));
-      return send(response, 200, { ...workspace.snapshot(url.searchParams.get('full') === '1'), workspaces: registry.workspaces.map((item) => item.describe()), problems: registry.problems, update: updater.status() });
+      return send(response, 200, { ...workspace.snapshot(url.searchParams.get('full') === '1'), workspaces: registry.workspaces.map((item) => item.describe()), problems: registry.problems, notifications: registry.notifications, update: updater.status() });
     }
     if (url.pathname === '/api/summary') {
-      return send(response, 200, { ...aggregateSummary(registry.workspaces), problems: registry.problems, handed: inbox.pending().length, update: updater.status() });
+      return send(response, 200, { ...aggregateSummary(registry.workspaces), problems: registry.problems, handed: inbox.pending().length, notifications: registry.notifications, update: updater.status() });
     }
     if (url.pathname === '/api/config') {
       const tables = Object.fromEntries(registry.workspaces.map((workspace) => [workspace.id, workspace.rulesTable]));
-      return send(response, 200, { workspaces: registry.rawWorkspaces, problems: registry.problems, connectors: connectorCatalogue(), fields: WORKSPACE_FIELDS, facts: FACTS, tables, table_warnings: normaliseWorkspaces(registry.rawWorkspaces).warnings, config_file: registry.configFile });
+      return send(response, 200, { workspaces: registry.rawWorkspaces, notifications: registry.notifications, problems: registry.problems, connectors: connectorCatalogue(), fields: WORKSPACE_FIELDS, facts: FACTS, tables, table_warnings: normaliseWorkspaces(registry.rawWorkspaces).warnings, config_file: registry.configFile });
     }
     if (url.pathname === '/api/changelog') {
       if (!changelog) {
@@ -185,10 +184,10 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
     if (url.pathname === '/api/feedback') {
       const id = url.searchParams.get('id');
       if (id) {
-        return send(response, 200, { report: await reports.detail(reportDeps(), id) });
+        return send(response, 200, { report: await reports.detail(id) });
       }
-      const list = await reports.states(reportDeps());
-      return send(response, 200, { configured: isConfigured(registry.feedback), project: registry.feedback ? registry.feedback.project : '', reports: list });
+      const list = await reports.states();
+      return send(response, 200, { reports: list });
     }
     if (url.pathname === '/api/handoff') {
       if (url.searchParams.get('all') === '1') {
@@ -240,6 +239,15 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
     return { ...target, value: String(item.value).trim() };
   });
 
+  const handleNotifications = async (body) => {
+    const desktop = desktopOf(body);
+    if (desktop === undefined) {
+      throw new ApiError('INVALID_ARGUMENT', { detail: 'desktop must be true or false' }, [{ field: 'desktop', description: 'Send {desktop: true} or {desktop: false}.' }]);
+    }
+    await registry.saveNotifications({ desktop });
+    return { notifications: registry.notifications };
+  };
+
   const handleConfig = async (body) => {
     if (!Array.isArray(body.workspaces)) {
       throw new ApiError('INVALID_ARGUMENT', { detail: 'workspaces must be a list' });
@@ -275,7 +283,7 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
       await secrets.set(secret.service, secret.account, secret.value);
     }
     await saveConfig(body.workspaces);
-    return { workspaces: registry.workspaces.map((workspace) => workspace.describe()), problems: registry.problems, secrets_stored: stored.map(({ service, account }) => ({ service, account })) };
+    return { workspaces: registry.workspaces.map((workspace) => workspace.describe()), notifications: registry.notifications, problems: registry.problems, secrets_stored: stored.map(({ service, account }) => ({ service, account })) };
   };
 
   const handleSecret = async (body) => {
@@ -321,12 +329,10 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
     return { item: inbox.add({ ws: workspace.id, ws_name: workspace.name, kind, ref, snapshot }) };
   };
 
-  const reportDeps = () => ({ settings: registry.feedback, secrets, http });
-
   let lastRemark = { text: '', at: 0 };
   const handleFeedback = async (body) => {
-    if (!isConfigured(registry.feedback)) {
-      throw new ApiError('NOT_CONFIGURED');
+    if ('context' in body) {
+      throw new ApiError('INVALID_ARGUMENT', { detail: 'context is no longer accepted: a report carries only its text and the monitor version' }, [{ field: 'context', description: 'Remove it; nothing but what the user wrote leaves this machine.' }]);
     }
     const remark = typeof body.text === 'string' ? body.text.trim() : '';
     if (!remark && !String(body.title || '').trim()) {
@@ -338,16 +344,12 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
     if (remark) {
       lastRemark = { text: remark, at: Date.now() };
     }
-    let context = null;
-    if (body.ws && body.kind_ref) {
-      const workspace = pick(body.ws);
-      context = workspace.handOffText(body.kind_ref.kind, body.kind_ref.ref);
-    }
+    const sources = (body.ws ? [pick(body.ws)] : registry.workspaces).flatMap((workspace) => workspace.sourceTypes);
     try {
       const composer = registry.feedback && registry.feedback.composer && registry.feedback.composer.command ? registry.feedback.composer : DEFAULT_COMPOSER;
-      const shaped = remark ? await composeIssue(remark, { about: context || '', composer, bugWords: registry.feedback && registry.feedback.bug_words }) : { kind: body.kind, title: body.title, body: body.body, composed_by: body.from || 'caller' };
-      const issue = await createFeedback({ settings: registry.feedback, secrets, http, cache: feedbackCache, reports }, { kind: shaped.kind, title: shaped.title, body: shaped.body, from: body.from, context: context || body.context || null });
-      return { issue, composed_by: shaped.composed_by, reports: await reports.states(reportDeps()) };
+      const shaped = remark ? await composeIssue(remark, { composer, bugWords: registry.feedback && registry.feedback.bug_words }) : { kind: body.kind, title: body.title, body: body.body, composed_by: body.from || 'caller' };
+      const issue = await createFeedback({ http, reports, relayUrl: reports.relayUrl, version, sources, install: installOf(appDir), client: body.client }, { kind: shaped.kind, title: shaped.title, body: shaped.body });
+      return { issue, composed_by: shaped.composed_by, reports: await reports.states() };
     } catch (error) {
       lastRemark = { text: '', at: 0 };
       throw error;
@@ -367,6 +369,9 @@ export const startApi = async ({ port, appDir, registry, requestPoll, saveConfig
     if (url.pathname === '/api/config') {
       return send(response, 200, await handleConfig(body));
     }
+    if (url.pathname === '/api/notifications') {
+      return send(response, 200, await handleNotifications(body));
+    }
     if (url.pathname === '/api/secrets') {
       return send(response, 200, await handleSecret(body));
     }

package/lib/compose.mjs

@@ -1,17 +1,15 @@
 /** Turns a remark into an issue (title, kind, body) with the user's own agent CLI, `claude -p` unless the config names another; falls back to the first line as the title. RMA-109. */
 import { execFile } from 'node:child_process';
 import { escapeRegex } from './text.mjs';
-import { untrustedBlock } from './handoff.mjs';
 
 const KINDS = ['bug', 'improvement', 'idea'];
 export const DEFAULT_COMPOSER = { command: 'claude', args: ['-p', '--output-format', 'json', '--model', 'claude-haiku-5-5'] };
 
-const PROMPT = (text, about) => `You turn a user's remark about a tool called Whose Turn (a local monitor of tickets and pull requests) into an issue for its backlog.
+const PROMPT = (text) => `You turn a user's remark about a tool called Whose Turn (a local monitor of tickets and pull requests) into an issue for its backlog.
 Answer with one JSON object only, no prose, no code fence: {"title": string, "kind": "bug" | "improvement" | "idea", "body": string}.
-Rules: the title and the body are in English whatever language the remark is in; translate faithfully, keep every detail the user gave, add nothing the user did not say. The title is one line under 80 characters; kind is bug when something misbehaves, improvement when something that exists should be better, idea when it is new; the body restates the remark clearly and may end with one line "Context: …" taken from the context below if it helps a developer find the place, and, when the remark was not in English, with one line "Original: …" quoting it as written.
+Rules: the title and the body are in English whatever language the remark is in; translate faithfully, keep every detail the user gave, add nothing the user did not say. The title is one line under 80 characters; kind is bug when something misbehaves, improvement when something that exists should be better, idea when it is new; the body restates the remark clearly and ends, when the remark was not in English, with one line "Original: …" quoting it as written.
 Remark:
-${text}
-${about ? `\nContext of the window at that moment:\n${untrustedBlock(about.slice(0, 3000))}` : ''}`;
+${text}`;
 
 const DEFAULT_BUG_WORDS = ['bug', 'broken', 'crash', 'error', 'fail', 'wrong'];
 const fallback = (text, bugWords) => {
@@ -50,8 +48,8 @@ const runCommand = (composer) => (prompt, timeoutMs) => new Promise((resolve, re
   child.stdin.end(prompt);
 });
 
-/** @param {string} text @param {{ about?: string, composer?: object, bugWords?: string[], run?: Function, timeoutMs?: number }} [options] */
-export const composeIssue = async (text, { about = '', composer = DEFAULT_COMPOSER, bugWords = [], run, timeoutMs = 45000 } = {}) => {
+/** @param {string} text @param {{ composer?: object, bugWords?: string[], run?: Function, timeoutMs?: number }} [options] */
+export const composeIssue = async (text, { composer = DEFAULT_COMPOSER, bugWords = [], run, timeoutMs = 45000 } = {}) => {
   const clean = String(text || '').trim();
   if (!clean) {
     throw new Error('Write at least one line');
@@ -60,7 +58,7 @@ export const composeIssue = async (text, { about = '', composer = DEFAULT_COMPOS
   const model = args[args.indexOf('--model') + 1];
   const label = composer.label || (args.includes('--model') && model ? `${composer.command} ${model}` : composer.command);
   try {
-    return parse(await (run || runCommand(composer))(PROMPT(clean, about), timeoutMs), label);
+    return parse(await (run || runCommand(composer))(PROMPT(clean), timeoutMs), label);
   } catch {
     return fallback(clean, bugWords);
   }

package/lib/config.mjs

@@ -2,6 +2,7 @@
 import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { isObject } from './text.mjs';
 import { isHex, derivedSeeds } from './palette.mjs';
 import { statusGroups } from './facts.mjs';
 import { tableProblems, tableWarnings } from './table.mjs';
@@ -115,8 +116,6 @@ const legacyWorkspace = (raw) => {
   return { id: 'default', name: 'Default', connectors, rules: raw.rules, key_pattern: raw.jira?.key_pattern };
 };
 
-const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
 const connectorEntries = (connectors) => {
   const list = Array.isArray(connectors) ? connectors : Object.entries(connectors || {}).map(([type, settings]) => ({ type, ...settings }));
   return list.filter(isObject).map((entry) => ({ ...entry, id: String(entry.id || entry.type) }));
@@ -243,7 +242,8 @@ export const loadConfig = (env = process.env) => {
     pollSeconds: Number(source.poll_seconds || 60),
     historyDays: Number(source.history_days || 14),
     health: normaliseHealth(source, problems),
-    feedback: source.feedback && typeof source.feedback === 'object' ? source.feedback : null,
+    feedback: withoutRetiredFeedbackKeys(source.feedback),
+    notifications: normaliseNotifications(source.notifications, problems),
     workspaces,
     rawWorkspaces,
     problems: [...problems, ...shapeProblems, ...warningLines],
@@ -259,6 +259,20 @@ const normaliseHealth = (source, problems) => Object.fromEntries(Object.entries(
   return [key, value];
 }));
 
+/** The boolean `desktop` of a notifications block, or undefined. */
+export const desktopOf = (notifications) => (isObject(notifications) && typeof notifications.desktop === 'boolean' ? notifications.desktop : undefined);
+
+const normaliseNotifications = (notifications, problems) => {
+  if (notifications === undefined) {
+    return { desktop: true };
+  }
+  const desktop = desktopOf(notifications);
+  if (desktop === undefined) {
+    problems.push('notifications.desktop must be true or false; desktop notifications stay on.');
+  }
+  return { desktop: desktop ?? true };
+};
+
 /** Field violations for entries that are not objects: a workspace, or a connector in a workspace's connectors list. Checked before normalising, which assumes objects. */
 export const entryShapeViolations = (rawWorkspaces) => (Array.isArray(rawWorkspaces) ? rawWorkspaces : []).flatMap((workspace, index) => {
   if (!isObject(workspace)) {
@@ -297,14 +311,33 @@ export const normaliseWorkspaces = (rawWorkspaces) => {
   return { workspaces, problems: violations.map((entry) => entry.description), violations, warnings };
 };
 
-/** Writes the workspace list into the config file, keeping its other top-level keys and dropping the flat pre-workspace keys; the previous file is kept as config.json.bak. */
+const RETIRED_FEEDBACK_KEYS = ['workspace', 'team', 'project', 'token_service', 'assign'];
+
+const withoutRetiredFeedbackKeys = (feedback) => (isObject(feedback) ? Object.fromEntries(Object.entries(feedback).filter(([key]) => !RETIRED_FEEDBACK_KEYS.includes(key))) : {});
+
+/** Writes the workspace list into the config file; the previous file stays as config.json.bak. */
 export const saveWorkspaces = (configFile, rawWorkspaces) => {
   const current = readJson(configFile);
   const source = current && !current.parse_error ? current : {};
   delete source.github;
   delete source.jira;
   delete source.rules;
-  const next = { ...source, workspaces: rawWorkspaces };
+  const feedback = withoutRetiredFeedbackKeys(source.feedback);
+  if (Object.keys(feedback).length) {
+    source.feedback = feedback;
+  } else {
+    delete source.feedback;
+  }
+  writeConfig(configFile, { ...source, workspaces: rawWorkspaces });
+};
+
+/** Writes the validated notifications block into the config file. */
+export const saveNotifications = (configFile, notifications) => {
+  const current = readJson(configFile);
+  writeConfig(configFile, { ...(current && !current.parse_error ? current : {}), notifications });
+};
+
+const writeConfig = (configFile, next) => {
   mkdirSync(dirname(configFile), { recursive: true });
   if (existsSync(configFile)) {
     writeFileSync(`${configFile}.bak.tmp`, readFileSync(configFile));

package/lib/errors.mjs

@@ -10,7 +10,6 @@ const REASONS = {
   INVALID_ARGUMENT: { code: 400, status: 'INVALID_ARGUMENT', message: 'A required value is missing or has the wrong shape.' },
   INVALID_CONFIG: { code: 400, status: 'INVALID_ARGUMENT', message: 'The workspace list has problems; nothing was saved.' },
   NO_WORKSPACE: { code: 412, status: 'FAILED_PRECONDITION', message: 'No workspace is configured; open Settings to add one.' },
-  NOT_CONFIGURED: { code: 412, status: 'FAILED_PRECONDITION', message: 'Feedback is not configured: set feedback.workspace, feedback.team and feedback.project in the config.' },
   UPSTREAM_FAILED: { code: 502, status: 'UNAVAILABLE', message: 'The tracker did not answer; try again in a minute.' },
   RATE_LIMITED: { code: 429, status: 'RESOURCE_EXHAUSTED', message: 'The source is rate-limited; try again later.' },
   OPEN_TOO_SOON: { code: 429, status: 'RESOURCE_EXHAUSTED', message: 'The window was just opened; wait a few seconds before opening it again.' },

package/lib/feedback.mjs

@@ -1,147 +1,115 @@
-/** Files a bug or an improvement about the monitor itself into its own Linear project, with the context the sender attaches. RMA-104. */
-import { join } from 'node:path';
+/** Files a bug or an improvement about the monitor itself through the maintainer's relay, and reads back what became of it. A report carries the kind, the title, the text, the version and a technical environment built here, nothing else. RMA-104, RMA-280, RMA-291. */
+import { release } from 'node:os';
+import { join, sep } from 'node:path';
 import { readJson, writeJson } from './store.mjs';
-import { nowIso } from './text.mjs';
+import { isObject, nowIso } from './text.mjs';
 import { ApiError } from './errors.mjs';
 import { RateLimited } from './http-client.mjs';
-import { linearQuery } from './linear-api.mjs';
 
-export const DEFAULT_SERVICE = 'whose-turn-feedback';
-const KINDS = { bug: 'Bug', improvement: 'Improvement', idea: 'Feature' };
+export const RELAY_URL = 'https://6cd7q2274i726zmnyav22ar2lu0fangt.lambda-url.eu-central-1.on.aws/';
+const PRODUCT = 'whose-turn';
+export const installOf = (appDir) => (appDir.split(sep).includes('node_modules') ? 'npm' : 'source');
+const MAX_IDS = 50;
+const STATE_NAMES = { open: 'Open', done: 'Done', dropped: 'Dropped' };
 
-const LOOKUP = `
-query Lookup($team: String!, $project: String!) {
-  viewer { id }
-  teams(filter: { key: { eq: $team } }) { nodes { id key labels { nodes { id name } } } }
-  projects(filter: { name: { eqIgnoreCase: $project } }) { nodes { id name } }
-}`;
-
-const STATES = `
-query States($team: String!, $numbers: [Float!]!) {
-  issues(first: 100, filter: { team: { key: { eq: $team } }, number: { in: $numbers } }) { nodes { identifier title url updatedAt state { name type } } }
-}`;
-
-const ANSWERS = `
-query Answers($id: String!) {
-  issue(id: $id) { comments(first: 50) { nodes { body createdAt user { name } } } }
-}`;
-
-const CREATE = `
-mutation Create($input: IssueCreateInput!) {
-  issueCreate(input: $input) { success issue { id identifier number url title } }
-}`;
-
-/** A Linear call; a rate limit, a failing answer or a GraphQL error comes out as the matching ApiError, the raw text only in its debug field. */
-const call = async (http, key, query, variables) => {
+const call = async (http, url, options) => {
   try {
-    return await linearQuery(http, key, query, variables);
+    return await http.fetchJson(url, { ...options, useEtag: false });
   } catch (error) {
-    const failure = error instanceof RateLimited ? new ApiError('RATE_LIMITED') : new ApiError('UPSTREAM_FAILED', error.upstreamStatus ? { upstream_status: error.upstreamStatus } : {});
+    const failure = error instanceof RateLimited
+      ? new ApiError('RATE_LIMITED')
+      : error.upstreamStatus === 400
+        ? new ApiError('INVALID_ARGUMENT', { detail: 'the tracker refused the report' })
+        : new ApiError('UPSTREAM_FAILED', error.upstreamStatus ? { upstream_status: error.upstreamStatus } : {});
     failure.debug = String(error.message);
     throw failure;
   }
 };
 
-const describe = ({ kind, body, context, from }) => [
-  body ? body.trim() : '',
-  '',
-  '---',
-  `Filed from Whose Turn by ${from || 'the window'} on ${nowIso()} as ${KINDS[kind] || kind}.`,
-  ...(context ? ['', typeof context === 'string' ? context.slice(0, 6000) : `\`\`\`json\n${JSON.stringify(context, null, 1).slice(0, 6000)}\n\`\`\``] : []),
-].join('\n');
-
-const serviceOf = (settings) => settings.token_service || DEFAULT_SERVICE;
-const keyFor = async (settings, secrets) => (settings && settings.workspace ? secrets.get(serviceOf(settings), settings.workspace) : '');
+const isSize = (value) => Number.isInteger(value) && value >= 1 && value <= 20000;
+const BROWSERS = ['Chrome', 'Edge', 'Safari', 'Firefox', 'Opera', 'Brave', 'Arc', 'Chromium', 'Other'];
+const exactly = (value, keys) => isObject(value) && Object.keys(value).sort().join() === keys;
 
-/** Which way an issue went: open, done, or dropped (canceled); the window and the report page see no Linear vocabulary. */
-const outcomeOf = (state) => ({ completed: 'done', canceled: 'dropped' }[state.type] || 'open');
+const CLIENT_FIELDS = {
+  browser: (value) => (exactly(value, 'name,version') && BROWSERS.includes(value.name) && typeof value.version === 'string' && /^\d{1,6}$/.test(value.version) ? { name: value.name, version: value.version } : undefined),
+  display: (value) => {
+    const sane = exactly(value, 'height,scale,viewport,width') && isSize(value.width) && isSize(value.height) && typeof value.scale === 'number' && value.scale >= 0.5 && value.scale <= 8 && Array.isArray(value.viewport) && value.viewport.length === 2 && value.viewport.every(isSize);
+    return sane ? { width: value.width, height: value.height, scale: Math.round(value.scale * 100) / 100, viewport: [...value.viewport] } : undefined;
+  },
+  locale: (value) => (typeof value === 'string' && value.length <= 35 && /^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$/.test(value) ? value : undefined),
+  timezone: (value) => (typeof value === 'string' && value.length <= 64 && /^[A-Za-z][A-Za-z0-9_+-]*(\/[A-Za-z0-9_+-]+)*$/.test(value) ? value : undefined),
+  theme: (value) => (value === 'light' || value === 'dark' ? value : undefined),
+  mode: (value) => (value === 'app' || value === 'tab' ? value : undefined),
+};
 
-const askLinear = async ({ settings, secrets, http }, query, variables) => {
-  const key = await keyFor(settings, secrets);
-  if (!key || !settings.team) {
-    return null;
-  }
-  try {
-    return await call(http, key, query, variables);
-  } catch {
-    return null;
+/** What the window reported about itself, keeping only the fields that are exactly the agreed shape; a bad or missing one is left out, never an error. RMA-291. */
+export const clientOf = (client) => {
+  const clean = {};
+  for (const [key, check] of Object.entries(CLIENT_FIELDS)) {
+    const value = isObject(client) ? check(client[key]) : undefined;
+    if (value !== undefined) {
+      clean[key] = value;
+    }
   }
+  return clean;
 };
 
-/** What this machine filed: the last hundred issues in <data>/reports.json. states() reads their Linear state, detail() one issue's comments as answers; both cached for a minute. RMA-120, RMA-123. */
-export const openReports = (dataDir) => {
+const environmentOf = ({ sources, install, client }) => ({ os: process.platform, osVersion: release(), arch: process.arch, node: process.version, install, sources: [...new Set(sources)].sort(), ...clientOf(client) });
+
+/** What this machine filed: the last hundred reports in <data>/reports.json. states() reads their state from the relay, detail() one report with its answers; one relay read serves both, cached for a minute. RMA-120, RMA-123. */
+export const openReports = (dataDir, { http, relayUrl }) => {
   const file = join(dataDir, 'reports.json');
   let items = readJson(file, []);
-  const cache = new Map();
-  const remembered = async (name, read) => {
-    const hit = cache.get(name);
-    if (hit && Date.now() - hit.at < 60000) {
-      return hit.value;
+  let cached = null;
+  const live = async () => {
+    if (cached && Date.now() - cached.at < 60000) {
+      return cached.value;
     }
-    const value = await read();
-    cache.set(name, { at: Date.now(), value });
+    let value = {};
+    if (items.length) {
+      try {
+        const ids = items.slice(0, MAX_IDS).map((report) => report.id).join(',');
+        const answer = await http.fetchJson(`${relayUrl}?product=${PRODUCT}&ids=${encodeURIComponent(ids)}`, { useEtag: false });
+        value = Object.fromEntries((answer.issues || []).map((issue) => [issue.identifier, issue]));
+      } catch {
+        value = {};
+      }
+    }
+    cached = { at: Date.now(), value };
     return value;
   };
-  const states = (deps) => remembered('states', async () => {
-    const data = items.length ? await askLinear(deps, STATES, { team: deps.settings.team, numbers: items.map((report) => report.number).filter(Number.isFinite) }) : null;
-    const live = Object.fromEntries((data ? data.issues.nodes : []).map((node) => [node.identifier, node]));
-    return items.map((report) => {
-      const issue = live[report.id];
-      return issue ? { ...report, title: issue.title, state: issue.state.name, outcome: outcomeOf(issue.state), changed_at: issue.updatedAt } : report;
-    });
-  });
+  const merged = (report, issue) => (issue ? { ...report, title: issue.title, state: STATE_NAMES[issue.outcome] || issue.outcome, outcome: issue.outcome, changed_at: issue.updatedAt } : report);
   return {
+    relayUrl,
     list: () => items.slice(),
-    add: (report) => { items = [report, ...items].slice(0, 100); cache.clear(); writeJson(file, items); return report; },
-    states,
-    detail: async (deps, id) => {
-      const report = (await states(deps)).find((item) => item.id === id);
+    add: (report) => { items = [report, ...items].slice(0, 100); cached = null; writeJson(file, items); return report; },
+    states: async () => {
+      const issues = await live();
+      return items.map((report) => merged(report, issues[report.id]));
+    },
+    detail: async (id) => {
+      const report = items.find((item) => item.id === id);
       if (!report) {
         return null;
       }
-      const answers = await remembered(`answers:${id}`, async () => {
-        const data = await askLinear(deps, ANSWERS, { id });
-        return (data && data.issue ? data.issue.comments.nodes : []).map((comment) => ({ at: comment.createdAt, by: comment.user ? comment.user.name : '', text: comment.body })).sort((a, b) => a.at.localeCompare(b.at));
-      });
-      return { ...report, answers, unanswered: Boolean(report.outcome) && report.outcome !== 'open' && !answers.length };
+      const issue = (await live())[id];
+      const answers = (issue ? issue.answers : []).map((answer) => ({ at: answer.at, by: answer.author || '', text: answer.body })).sort((a, b) => a.at.localeCompare(b.at));
+      const shown = merged(report, issue);
+      return { ...shown, answers, unanswered: Boolean(shown.outcome) && shown.outcome !== 'open' && !answers.length };
     },
   };
 };
 
-/** True when the config names the Linear workspace, team and project reports go to. */
-export const isConfigured = (settings) => Boolean(settings && settings.workspace && settings.team && settings.project);
-
-export const createFeedback = async ({ settings, secrets, http, cache, reports }, { kind = 'improvement', title, body = '', context = null, from = '' }) => {
-  if (!isConfigured(settings)) {
-    throw new ApiError('NOT_CONFIGURED');
-  }
-  const cleanTitle = String(title || '').trim().slice(0, 200);
+/** Files a report through the relay; returns {identifier, url, title}. */
+export const createFeedback = async ({ http, relayUrl, reports, version, sources = [], install = 'source', client = null }, { kind = 'improvement', title, body = '' }) => {
+  const cleanTitle = String(title || '').trim().slice(0, 140);
   if (!cleanTitle) {
     throw new ApiError('INVALID_ARGUMENT', { detail: 'a title is required' }, [{ field: 'title', description: 'A report needs a title.' }]);
   }
-  const key = await keyFor(settings, secrets);
-  if (!key) {
-    throw new ApiError('NOT_CONFIGURED', { detail: `no Linear key for feedback in the secret store (service ${serviceOf(settings)}, account ${settings.workspace})` });
-  }
-  if (!cache.lookup) {
-    const data = await call(http, key, LOOKUP, { team: settings.team, project: settings.project });
-    const team = data.teams.nodes[0];
-    const project = data.projects.nodes[0];
-    if (!team || !project) {
-      throw new ApiError('NOT_CONFIGURED', { detail: `Linear team ${settings.team} or project ${settings.project} not found` });
-    }
-    cache.lookup = { teamId: team.id, projectId: project.id, assigneeId: data.viewer?.id || '', labels: Object.fromEntries(team.labels.nodes.map((label) => [label.name.toLowerCase(), label.id])) };
-  }
-  const labelId = cache.lookup.labels[(KINDS[kind] || kind).toLowerCase()];
-  const assigneeId = settings.assign === false ? '' : cache.lookup.assigneeId;
-  const input = { teamId: cache.lookup.teamId, projectId: cache.lookup.projectId, title: cleanTitle, description: describe({ kind, body, context, from }), ...(labelId ? { labelIds: [labelId] } : {}), ...(assigneeId ? { assigneeId } : {}) };
-  const data = await call(http, key, CREATE, { input });
-  if (!data.issueCreate?.success) {
-    throw new ApiError('UPSTREAM_FAILED');
-  }
-  const issue = data.issueCreate.issue;
+  const text = String(body || '').trim().slice(0, 6000);
+  const issue = await call(http, relayUrl, { method: 'POST', body: { product: PRODUCT, kind, title: cleanTitle, body: text || cleanTitle, version: version || undefined, environment: environmentOf({ sources, install, client }) } });
   if (reports) {
-    reports.add({ id: issue.identifier, number: issue.number, url: issue.url, title: issue.title, kind, body: String(body || '').trim(), filed_at: nowIso() });
+    reports.add({ id: issue.identifier, url: issue.url, title: cleanTitle, kind, body: text, filed_at: nowIso() });
   }
-  return issue;
+  return { identifier: issue.identifier, url: issue.url, title: cleanTitle };
 };

package/lib/linear-api.mjs

@@ -1,4 +1,4 @@
-/** The one Linear GraphQL client, shared by the Linear connector and the feedback composer. */
+/** The one Linear GraphQL client, used by the Linear connector. */
 
 const API = 'https://api.linear.app/graphql';
 

package/lib/notify.mjs

@@ -35,9 +35,13 @@ const launch = (file, args, env) => {
   }
 };
 
-export const notify = (title, body, { platform = process.platform, run = launch } = {}) => {
+/** Sends one desktop notification; `enabled: false` stays silent. */
+export const notify = (title, body, { platform = process.platform, run = launch, enabled = true } = {}) => {
   const build = COMMANDS[platform];
-  if (build) {
+  if (build && enabled) {
     run(...build(clean(title, 120), clean(body, 240)));
   }
 };
+
+/** A notify function that asks `isOn()` on every call. */
+export const notifier = (isOn) => (title, body) => notify(title, body, { enabled: isOn() });

package/lib/registry.mjs

@@ -1,9 +1,9 @@
 /** The live set of workspaces: built from the config, rebuilt on save with unchanged workspaces kept, events fanned in for the SSE stream. */
 import { ApiError } from './errors.mjs';
 
-export const createRegistry = ({ load, save, build, normalise = (raw) => raw }) => {
+export const createRegistry = ({ load, save, saveNotifications, build, normalise = (raw) => raw }) => {
   const listeners = new Set();
-  const registry = { workspaces: [], rawWorkspaces: [], problems: [], configFile: '', feedback: null, subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); } };
+  const registry = { workspaces: [], rawWorkspaces: [], problems: [], configFile: '', feedback: null, notifications: { desktop: true }, subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); } };
 
   const apply = (config, prebuilt = new Map()) => {
     const previous = new Map(registry.workspaces.map((workspace) => [workspace.id, workspace]));
@@ -29,6 +29,7 @@ export const createRegistry = ({ load, save, build, normalise = (raw) => raw })
     }).filter(Boolean);
     registry.rawWorkspaces = config.rawWorkspaces;
     registry.feedback = config.feedback;
+    registry.notifications = config.notifications;
     registry.problems = [...config.problems, ...dropped];
     registry.configFile = config.configFile;
     return created;
@@ -56,6 +57,10 @@ export const createRegistry = ({ load, save, build, normalise = (raw) => raw })
     await save(rawWorkspaces);
     return apply(load(), prebuilt);
   };
+  registry.saveNotifications = async (notifications) => {
+    await saveNotifications(notifications);
+    registry.reload();
+  };
   registry.reload();
   return registry;
 };

package/lib/text.mjs

@@ -16,6 +16,9 @@ export const oneline = (text, limit = 140) => {
   return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}…`;
 };
 
+/** True for a plain object: not null, not an array. */
+export const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
 export const escapeRegex = (text) => String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
 export const wordsRegex = (words, flags = 'i') => new RegExp(words.length ? words.map(escapeRegex).join('|') : '(?!)', flags);

package/lib/workspace.mjs

@@ -366,7 +366,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   };
 
   return {
-    id: definition.id, name: definition.name, rulesTable: rules.table, store, poll, snapshot, summary, describe, checkHealth, handOff, handOffBody, handOffText, handOffSnapshot, updateMarks, addTodo, changeTodo, saveTodos,
+    id: definition.id, name: definition.name, sourceTypes: [...new Set(definition.connectors.map((entry) => entry.type))], rulesTable: rules.table, store, poll, snapshot, summary, describe, checkHealth, handOff, handOffBody, handOffText, handOffSnapshot, updateMarks, addTodo, changeTodo, saveTodos,
     subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whose-turn",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.8",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server.mjs

@@ -3,16 +3,16 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { loadConfig, saveWorkspaces, normaliseWorkspaces } from './lib/config.mjs';
+import { loadConfig, saveWorkspaces, saveNotifications, normaliseWorkspaces } from './lib/config.mjs';
 import { createHttpClient } from './lib/http-client.mjs';
 import { nextDelay } from './lib/backoff.mjs';
 import { createSecrets } from './lib/secrets.mjs';
 import { createWorkspace } from './lib/workspace.mjs';
 import { createRegistry } from './lib/registry.mjs';
 import { openInbox } from './lib/inbox.mjs';
-import { openReports } from './lib/feedback.mjs';
+import { openReports, RELAY_URL } from './lib/feedback.mjs';
 import { startApi } from './lib/api.mjs';
-import { notify } from './lib/notify.mjs';
+import { notifier } from './lib/notify.mjs';
 import { loadChangelog } from './lib/changelog.mjs';
 import { createUpdater, restartServer, runsInstalled } from './lib/update.mjs';
 
@@ -21,9 +21,10 @@ const http = createHttpClient();
 const first = loadConfig();
 const secrets = createSecrets(first.dataDir);
 const inbox = openInbox(first.dataDir);
-const reports = openReports(first.dataDir);
+const reports = openReports(first.dataDir, { http, relayUrl: process.env.WHOSE_TURN_FEEDBACK_URL || RELAY_URL });
 const { version } = JSON.parse(readFileSync(join(appDir, 'package.json'), 'utf8'));
 let server;
+const notify = notifier(() => registry.notifications.desktop);
 const updater = createUpdater({
   http,
   dataDir: first.dataDir,
@@ -46,8 +47,9 @@ const registry = createRegistry({
     return config;
   },
   save: (rawWorkspaces) => saveWorkspaces(first.configFile, rawWorkspaces),
+  saveNotifications: (notifications) => saveNotifications(first.configFile, notifications),
   normalise: (rawWorkspaces) => normaliseWorkspaces(rawWorkspaces).workspaces,
-  build: (definition, config) => createWorkspace(definition, { dataDir: config.dataDir, historyDays: config.historyDays, http, secrets, limits: () => healthLimits }),
+  build: (definition, config) => createWorkspace(definition, { dataDir: config.dataDir, historyDays: config.historyDays, http, secrets, limits: () => healthLimits, notify }),
 });
 
 let wake = null;
@@ -72,7 +74,7 @@ const saveConfig = async (rawWorkspaces) => {
 };
 
 try {
-  server = await startApi({ port: first.port, appDir, registry, requestPoll, saveConfig, secrets, inbox, http, reports, dataDir: first.dataDir, updater, changelog: loadChangelog(appDir, version) });
+  server = await startApi({ port: first.port, appDir, registry, requestPoll, saveConfig, secrets, inbox, http, reports, dataDir: first.dataDir, updater, changelog: loadChangelog(appDir, version), version });
 } catch (error) {
   console.error(error.message);
   process.exit(1);