flagon-io/g1t

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

Inbox: the events service tells people what needs them as events arrive2d ago		1	//! The inbox, kept beside the event log. See `g1t_contracts::inbox`.
		2	//!
Inbox: threads, reasons, subscriptions and watching2d ago		3	//! As each batch arrives from the bus, the events that tell someone are
		4	//! read against what they name (the work service's `inbox_subject`), who
		5	//! subscribes to it and who watches its repository (subscriptions.rs), and
		6	//! each person told gets their thread about it brought to the top, unread,
		7	//! with a line added to its history. Who is told is worked out in
		8	//! [`notices`], from the event, its subject and that audience alone:
Inbox: the events service tells people what needs them as events arrive2d ago		9	//!
Inbox: threads, reasons, subscriptions and watching2d ago		10	//! | Event | Who | Reason | Severity |
		11	//! | --- | --- | --- | --- |
		12	//! | `agent.asked`, `pull.stalled` | the pull request's owner, and its issue's owner and assignees | agent | warning |
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		13	//! | `pull.review_requested` | the reviewers asked, and the people each team asked tells | review_requested | warning |
Inbox: threads, reasons, subscriptions and watching2d ago		14	//! | `issue.assigned`, `pull.assigned` | the people newly assigned | assign | info |
		15	//! | `checks.completed`, failed or errored | the pull request's owner | ci_activity | error |
		16	//! | `workflow.completed`, failed | the pull request's owner, or whoever pushed | ci_activity | error |
		17	//! | `deployment.failed` | the pull request's owner, or whoever pushed; watchers | ci_activity | error |
		18	//! | `deployment.succeeded` after a failure | the same | ci_activity | success |
		19	//! | `review.completed` by g1t | the pull request's owner | author | success, or info for changes asked |
		20	//! | `pull.ready` for a change g1t made | whoever asked g1t for it | author | success |
		21	//! | `pull.merged`, `pull.closed`, `issue.closed`, `issue.reopened` | everyone subscribed | state_change | success for a merge, else info |
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		22	//! | `comment.created` | everyone mentioned, the people of teams mentioned, then everyone subscribed | mention, team_mention, or why they are subscribed | info (success for an approval) |
		23	//! | `issue.opened`, `pull.opened` | whoever was assigned, asked to review or mentioned in its description (people and teams); watchers | assign, review_requested, mention, team_mention, subscribed | info |
Inbox: the events service tells people what needs them as events arrive2d ago		24	//!
Inbox: threads, reasons, subscriptions and watching2d ago		25	//! Watchers of a repository at `all` (or `custom`, for the kinds they
		26	//! chose) hear of every issue and pull request opened, commented on,
		27	//! closed, reopened or merged, and of deployments. Anyone who ignores the
		28	//! thread or the repository hears of nothing on it; anyone who
		29	//! unsubscribed hears only of what is asked of them.
		30	//!
		31	//! Nobody is told of what they did themselves, though an outcome they set
		32	//! off (checks, a workflow, a deployment, g1t's work) is theirs to hear of.
		33	//! g1t is never told. A failure here is logged and the batch goes on: the
		34	//! bus never waits on the inbox, so an item can be missed, but nothing else
		35	//! is held up.
Inbox: the events service tells people what needs them as events arrive2d ago		36
		37	use std::collections::{HashMap, HashSet};
		38
		39	use g1t_contracts::credentials::Principal;
		40	use g1t_contracts::events::{Event, WorkspaceRenamed};
		41	use g1t_contracts::identity::{AGENT_ID, UsernamesArgs};
		42	use g1t_contracts::inbox::*;
		43	use g1t_contracts::repos::{PathByIdArgs, ReadableArgs, Repo, RepoPath};
		44	use g1t_contracts::time::rfc3339;
		45	use g1t_contracts::{new_id, system};
		46	use g1t_kit::now_ms;
		47	use serde::Deserialize;
		48	use worker::wasm_bindgen::JsValue;
Inbox: threads, reasons, subscriptions and watching2d ago		49	use worker::{D1Database, D1PreparedStatement, Fetcher, Result};
		50
		51	use crate::subscriptions::{self, Audience};
Inbox: the events service tells people what needs them as events arrive2d ago		52
		53	/// Items marked done are kept this long, then removed.
		54	pub const DONE_DAYS: u32 = 30;
		55	/// No item is kept longer than this, unless it was saved.
		56	pub const MAX_DAYS: u32 = 180;
		57	/// Unread warnings shown ahead of everything else on the first page.
		58	const MAX_RANKED: u32 = 20;
		59	const MAX_TITLE: usize = 200;
		60	const MAX_BODY: usize = 300;
		61
		62	/// What the inbox asks about an event before deciding who is told.
		63	#[derive(Debug, PartialEq, Eq)]
		64	pub struct Wanted {
		65	pub repo_id: String,
		66	/// The issue or pull request, when the event names one.
		67	pub number: Option<u32>,
		68	pub comment_id: Option<String>,
		69	}
		70
		71	/// One person to tell, and what.
		72	#[derive(Debug, PartialEq, Eq)]
		73	pub struct Notice {
		74	pub username: String,
Inbox: threads, reasons, subscriptions and watching2d ago		75	pub reason: Reason,
Inbox: the events service tells people what needs them as events arrive2d ago		76	pub severity: Severity,
		77	pub title: String,
		78	pub body: String,
		79	}
		80
		81	/// Who did it, as far as is known.
		82	#[derive(Debug, Default)]
		83	pub struct Actor {
		84	pub id: Option<String>,
		85	pub username: Option<String>,
		86	}
		87
		88	impl Actor {
		89	fn is(&self, person: &Principal) -> bool {
		90	self.id.as_deref().is_some_and(|id| id == person.id) || self.is_named(&person.username)
		91	}
		92
		93	fn is_named(&self, username: &str) -> bool {
		94	self.username.as_deref().is_some_and(|name| name.eq_ignore_ascii_case(username))
		95	}
Inbox: threads, reasons, subscriptions and watching2d ago		96
		97	/// A person's name, for a title: never g1t's ids.
		98	fn name(&self) -> Option<&str> {
		99	self.username.as_deref().filter(|name| !is_g1t(name))
		100	}
Inbox: the events service tells people what needs them as events arrive2d ago		101	}
		102
Inbox: threads, reasons, subscriptions and watching2d ago		103	pub(crate) fn is_g1t(username: &str) -> bool {
Inbox: the events service tells people what needs them as events arrive2d ago		104	username.eq_ignore_ascii_case(system::USERNAME) || username.eq_ignore_ascii_case("g1t-agent")
		105	}
		106
Inbox: threads, reasons, subscriptions and watching2d ago		107	pub(crate) fn is_g1t_id(id: &str) -> bool {
Inbox: the events service tells people what needs them as events arrive2d ago		108	system::is_system_id(id) || id == AGENT_ID
		109	}
		110
Inbox: threads, reasons, subscriptions and watching2d ago		111	/// Events that end what an agent was waiting on a person for: it picked
		112	/// back up, its head moved, a merge was asked for, or it is over.
		113	const RESUMES: [&str; 5] = ["pull.resumed", "pull.updated", "pull.merge_requested", "pull.merged", "pull.closed"];
		114
Inbox: the events service tells people what needs them as events arrive2d ago		115	/// The issue or pull request an event names, and what to read for it.
		116	/// None for events the inbox does not tell anyone of.
		117	pub fn wants(event: &Event) -> Option<Wanted> {
		118	let data = &event.data;
		119	let text = |key: &str| data[key].as_str().filter(|value| !value.is_empty()).map(str::to_owned);
		120	let number = |key: &str| data[key].as_u64().and_then(|n| u32::try_from(n).ok());
		121	let repo_id = text("repoId").or_else(|| event.repo_id.clone())?;
		122	let on = |number: Option<u32>, comment_id: Option<String>| {
		123	Some(Wanted {
		124	repo_id: repo_id.clone(),
		125	number,
		126	comment_id,
		127	})
		128	};
		129	match event.kind.as_str() {
Inbox: threads, reasons, subscriptions and watching2d ago		130	"agent.asked" | "pull.stalled" | "pull.merged" | "pull.closed" | "pull.ready" | "pull.opened"
		131	| "pull.review_requested" | "pull.assigned" | "issue.opened" | "issue.closed" | "issue.reopened"
		132	| "issue.assigned" => on(Some(number("number")?), None),
Inbox: the events service tells people what needs them as events arrive2d ago		133	"checks.completed" => match data["status"].as_str() {
		134	Some("failed" | "errored") => on(Some(number("number")?), None),
		135	_ => None,
		136	},
		137	"review.completed" => match data["verdict"].as_str() {
		138	Some("approve" | "request_changes") => on(Some(number("number")?), None),
		139	_ => None,
		140	},
		141	"workflow.completed" => match data["conclusion"].as_str() {
		142	Some("failure") => on(number("pull"), None),
		143	_ => None,
		144	},
Inbox: threads, reasons, subscriptions and watching2d ago		145	"deployment.failed" | "deployment.succeeded" => on(number("number"), None),
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		146	// A workflow run's jobs wait for their environment's reviewers.
		147	"deployment.review_requested" => on(None, None),
Inbox: the events service tells people what needs them as events arrive2d ago		148	"comment.created" => on(Some(number("number")?), Some(text("commentId")?)),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		149	// Security alerts are threads of their own, not of an issue.
		150	kind if SECURITY_EVENTS.contains(&kind) => on(None, None),
Inbox: the events service tells people what needs them as events arrive2d ago		151	_ => None,
		152	}
		153	}
		154
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		155	/// The security service's events the inbox tells people of: new alerts,
		156	/// and push protection bypasses asked for and decided. Fixes and
		157	/// dismissals are on the Security page and in webhooks.
		158	pub const SECURITY_EVENTS: [&str; 5] = [
		159	"secret_scanning_alert.created",
		160	"code_scanning_alert.created",
		161	"vulnerability_alert.created",
		162	"secret_scanning.bypass_requested",
		163	"secret_scanning.bypass_reviewed",
		164	];
		165
Inbox: threads, reasons, subscriptions and watching2d ago		166	/// Where an event's items go: which thread, what it is, and where it is.
		167	#[derive(Clone, Debug, PartialEq, Eq)]
		168	pub struct Thread {
		169	pub key: String,
		170	pub kind: Option<SubjectKind>,
		171	pub number: Option<u32>,
		172	pub run_id: Option<String>,
		173	/// A path, for a subject with a page of its own.
		174	pub link: Option<String>,
		175	}
		176
		177	/// The thread key of an issue or pull request.
		178	pub fn numbered_thread(repo_id: &str, number: u32) -> String {
		179	format!("{repo_id}#{number}")
		180	}
		181
		182	/// The thread an event's items go to.
		183	pub fn thread_of(event: &Event, wanted: &Wanted, subject: Option<&InboxSubject>) -> Thread {
		184	let data = &event.data;
		185	let text = |key: &str| data[key].as_str().filter(|value| !value.is_empty()).map(str::to_owned);
		186	match event.kind.as_str() {
		187	// A project's production, or one pull request's preview.
		188	"deployment.failed" | "deployment.succeeded" => {
		189	let which = wanted.number.map_or_else(|| "production".to_owned(), |number| number.to_string());
		190	Thread {
		191	key: format!("{}/deploy/{}/{which}", wanted.repo_id, text("projectId").unwrap_or_default()),
		192	kind: Some(SubjectKind::Deploy),
		193	number: wanted.number,
		194	run_id: text("deploymentId"),
		195	link: text("path"),
		196	}
		197	}
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		198	// One run's deployment to one environment, waiting for review.
		199	"deployment.review_requested" => Thread {
		200	key: format!(
		201	"{}/review/{}/{}",
		202	wanted.repo_id,
		203	text("runId").unwrap_or_default(),
		204	text("environment").unwrap_or_default()
		205	),
		206	kind: Some(SubjectKind::Run),
		207	number: None,
		208	run_id: text("runId"),
		209	link: text("link"),
		210	},
Inbox: threads, reasons, subscriptions and watching2d ago		211	// A workflow on a branch: its next failure bumps the same thread.
		212	"workflow.completed" if subject.is_none() => {
		213	let branch = text("ref").unwrap_or_default();
		214	let branch = branch.strip_prefix("refs/heads/").unwrap_or(&branch).to_owned();
		215	let workflow = text("path").or_else(|| text("workflow")).unwrap_or_default();
		216	Thread {
		217	key: format!("{}/run/{workflow}@{branch}", wanted.repo_id),
		218	kind: Some(SubjectKind::Run),
		219	number: None,
		220	run_id: text("runId"),
		221	link: None,
		222	}
		223	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		224	// One alert, or one bypass request: its page is the link.
		225	kind if SECURITY_EVENTS.contains(&kind) => {
		226	let which = text("requestId").or_else(|| text("alertId")).unwrap_or_else(|| event.id.clone());
		227	Thread {
		228	key: format!("{}/security/{which}", wanted.repo_id),
		229	kind: None,
		230	number: None,
		231	run_id: None,
		232	link: text("link"),
		233	}
		234	}
Inbox: threads, reasons, subscriptions and watching2d ago		235	_ => match wanted.number {
		236	Some(number) => Thread {
		237	key: numbered_thread(&wanted.repo_id, number),
		238	kind: subject.and_then(|subject| subject.kind),
		239	number: Some(number),
		240	run_id: None,
		241	link: None,
		242	},
		243	None => Thread {
		244	key: format!("event/{}", event.id),
		245	kind: None,
		246	number: None,
		247	run_id: None,
		248	link: None,
		249	},
		250	},
		251	}
		252	}
		253
		254	/// The issue or pull request whose agent threads an event closes: what an
		255	/// agent was waiting on a person for is over.
		256	pub fn resolves(event: &Event) -> Option<String> {
		257	if !RESUMES.contains(&event.kind.as_str()) {
		258	return None;
		259	}
		260	let repo_id = event.data["repoId"].as_str().map(str::to_owned).or_else(|| event.repo_id.clone())?;
		261	let number = event.data["number"].as_u64().and_then(|n| u32::try_from(n).ok())?;
		262	Some(numbered_thread(&repo_id, number))
		263	}
		264
		265	/// Collects who is told, each once with the most specific reason, never
		266	/// the actor, never g1t, and never anyone ignoring the thread.
Inbox: the events service tells people what needs them as events arrive2d ago		267	struct Told<'a> {
		268	actor: &'a Actor,
Inbox: threads, reasons, subscriptions and watching2d ago		269	audience: &'a Audience,
Inbox: the events service tells people what needs them as events arrive2d ago		270	notices: Vec<Notice>,
		271	}
		272
		273	impl Told<'_> {
Inbox: threads, reasons, subscriptions and watching2d ago		274	/// `asked`: something asked of the person directly, told even when
		275	/// they unsubscribed from the thread.
		276	fn tell(&mut self, username: &str, reason: Reason, severity: Severity, title: &str, body: &str, asked: bool) {
Inbox: the events service tells people what needs them as events arrive2d ago		277	let username = username.trim().trim_start_matches('@').to_lowercase();
		278	if username.is_empty()
		279	|| is_g1t(&username)
		280	|| self.actor.is_named(&username)
Inbox: threads, reasons, subscriptions and watching2d ago		281	|| self.audience.ignores(&username)
		282	|| (!asked && self.audience.unsubscribed(&username))
Inbox: the events service tells people what needs them as events arrive2d ago		283	{
		284	return;
		285	}
Inbox: threads, reasons, subscriptions and watching2d ago		286	let notice = Notice {
Inbox: the events service tells people what needs them as events arrive2d ago		287	username,
		288	reason,
		289	severity,
		290	title: clip(title, MAX_TITLE),
		291	body: clip(body, MAX_BODY),
Inbox: threads, reasons, subscriptions and watching2d ago		292	};
		293	match self.notices.iter_mut().find(|told| told.username == notice.username) {
		294	Some(told) if notice.reason.rank() < told.reason.rank() => *told = notice,
		295	Some(_) => {}
		296	None => self.notices.push(notice),
		297	}
Inbox: the events service tells people what needs them as events arrive2d ago		298	}
		299
		300	/// A person known by id as well as name, such as an author.
Inbox: threads, reasons, subscriptions and watching2d ago		301	fn tell_person(&mut self, person: &Principal, reason: Reason, severity: Severity, title: &str, body: &str, asked: bool) {
Inbox: the events service tells people what needs them as events arrive2d ago		302	if is_g1t_id(&person.id) || self.actor.is(person) {
		303	return;
		304	}
Inbox: threads, reasons, subscriptions and watching2d ago		305	self.tell(&person.username, reason, severity, title, body, asked);
		306	}
		307
		308	/// Everyone subscribed to an issue or pull request: its owner and
		309	/// author, its assignees and reviewers, and whoever subscribed by
		310	/// commenting, being mentioned or by hand. `reason` overrides why
		311	/// each is told, as a state change does.
		312	fn tell_subscribed(&mut self, subject: &InboxSubject, reason: Option<Reason>, severity: Severity, title: &str, body: &str) {
		313	let why = |own: Reason| reason.unwrap_or(own);
		314	self.tell_person(subject.owner(), why(Reason::Author), severity, title, body, false);
		315	self.tell_person(&subject.author, why(Reason::Author), severity, title, body, false);
		316	for name in &subject.assignees {
		317	self.tell(name, why(Reason::Assign), severity, title, body, false);
		318	}
		319	for name in &subject.reviewers {
		320	self.tell(name, why(Reason::ReviewRequested), severity, title, body, false);
		321	}
		322	let subscribed: Vec<(String, Reason)> = self.audience.subscribed().collect();
		323	for (name, own) in subscribed {
		324	self.tell(&name, why(own), severity, title, body, false);
		325	}
Inbox: the events service tells people what needs them as events arrive2d ago		326	}
Inbox: threads, reasons, subscriptions and watching2d ago		327
		328	/// Everyone watching the repository for this kind of activity.
		329	fn tell_watchers(&mut self, kind: &str, severity: Severity, title: &str, body: &str) {
		330	let watching: Vec<String> = self.audience.watching(kind).collect();
		331	for name in watching {
		332	self.tell(&name, Reason::Subscribed, severity, title, body, false);
		333	}
		334	}
Inbox: the events service tells people what needs them as events arrive2d ago		335	}
		336
		337	fn clip(text: &str, max: usize) -> String {
		338	let text = text.trim();
		339	if text.chars().count() <= max {
		340	return text.to_owned();
		341	}
		342	let cut: String = text.chars().take(max - 1).collect();
		343	format!("{}…", cut.trim_end())
		344	}
		345
Inbox: threads, reasons, subscriptions and watching2d ago		346	/// The kind of activity a watcher chooses: `issues` or `pulls`.
		347	fn activity_of(subject: &InboxSubject) -> &'static str {
		348	match subject.kind {
		349	Some(SubjectKind::Pull) => "pulls",
		350	_ => "issues",
		351	}
		352	}
		353
		354	/// The names in an event's list field, such as the reviewers just asked.
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		355	/// The teams an event asked to review: each `workspace/slug` with the
		356	/// people it tells.
		357	fn teams_asked(data: &serde_json::Value) -> Vec<(String, Vec<String>)> {
		358	data["teams"]
		359	.as_array()
		360	.map(|teams| {
		361	teams
		362	.iter()
		363	.filter_map(|team| Some((team["team"].as_str()?.to_owned(), names(team, "notified"))))
		364	.collect()
		365	})
		366	.unwrap_or_default()
		367	}
		368
Inbox: threads, reasons, subscriptions and watching2d ago		369	fn names(data: &serde_json::Value, key: &str) -> Vec<String> {
		370	data[key]
		371	.as_array()
		372	.map(|names| names.iter().filter_map(|name| name.as_str().map(str::to_owned)).collect())
		373	.unwrap_or_default()
		374	}
		375
		376	/// Who is told of `event`, in `repo` (`owner/name`), given what it names
		377	/// and who follows it. `actor` is who caused it; outcomes nobody chose
		378	/// (checks, workflows, deployments, a review, an agent finishing or
		379	/// stopping) are told whoever caused them.
		380	pub fn notices(event: &Event, repo: &str, actor: &Actor, subject: Option<&InboxSubject>, audience: &Audience) -> Vec<Notice> {
Inbox: the events service tells people what needs them as events arrive2d ago		381	let nobody = Actor::default();
		382	let data = &event.data;
		383	// The issue or pull request, as titles name it: `acme/rocket#12`.
		384	let at = match data["number"].as_u64().or(data["pull"].as_u64()) {
		385	Some(number) if subject.is_some() => format!("{repo}#{number}"),
		386	_ => repo.to_owned(),
		387	};
		388	let outcome = matches!(
		389	event.kind.as_str(),
Inbox: threads, reasons, subscriptions and watching2d ago		390	"checks.completed"
		391	| "workflow.completed"
		392	| "review.completed"
		393	| "pull.ready"
		394	| "agent.asked"
		395	| "pull.stalled"
		396	| "deployment.failed"
		397	| "deployment.succeeded"
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		398	| "deployment.review_requested"
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		399	) || SECURITY_EVENTS.contains(&event.kind.as_str());
Inbox: the events service tells people what needs them as events arrive2d ago		400	let mut told = Told {
		401	actor: if outcome { &nobody } else { actor },
Inbox: threads, reasons, subscriptions and watching2d ago		402	audience,
Inbox: the events service tells people what needs them as events arrive2d ago		403	notices: Vec::new(),
		404	};
Inbox: threads, reasons, subscriptions and watching2d ago		405	// Who did it, as titles name them.
		406	let who = actor.name().unwrap_or("g1t");
Inbox: the events service tells people what needs them as events arrive2d ago		407
		408	match (event.kind.as_str(), subject) {
Inbox: threads, reasons, subscriptions and watching2d ago		409	("agent.asked" | "pull.stalled", Some(pull)) => {
		410	let (title, body) = if event.kind == "agent.asked" {
		411	(format!("An agent is waiting on {at}"), pull.title.clone())
		412	} else {
		413	let detail = data["detail"].as_str().map(str::trim).filter(|detail| !detail.is_empty());
		414	(format!("g1t stopped on {at} and needs you"), detail.unwrap_or(&pull.title).to_owned())
		415	};
		416	told.tell_person(pull.owner(), Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive2d ago		417	if let Some(issue) = &pull.issue {
Inbox: threads, reasons, subscriptions and watching2d ago		418	told.tell_person(issue.owner(), Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive2d ago		419	for name in &issue.assignees {
Inbox: threads, reasons, subscriptions and watching2d ago		420	told.tell(name, Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive2d ago		421	}
		422	}
		423	}
Inbox: threads, reasons, subscriptions and watching2d ago		424	("pull.review_requested", Some(pull)) => {
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		425	// Asked because the CODEOWNERS file says they own what changed.
		426	let owned = data["codeOwners"].as_bool() == Some(true);
		427	let title = if owned {
		428	format!("{at} changes files you own")
		429	} else {
		430	format!("{who} asked you to review {at}")
		431	};
Inbox: threads, reasons, subscriptions and watching2d ago		432	for name in names(data, "reviewers") {
		433	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, &pull.title, true);
		434	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		435	for (team, people) in teams_asked(data) {
		436	let title = if owned {
		437	format!("{at} changes files @{team} owns")
		438	} else {
		439	format!("{who} asked @{team} to review {at}")
		440	};
		441	for name in people {
		442	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, &pull.title, true);
		443	}
		444	}
Inbox: threads, reasons, subscriptions and watching2d ago		445	}
		446	("issue.assigned" | "pull.assigned", Some(on)) => {
		447	let title = format!("{who} assigned you to {at}");
		448	for name in names(data, "added") {
		449	told.tell(&name, Reason::Assign, Severity::Info, &title, &on.title, true);
		450	}
		451	}
		452	("issue.opened" | "pull.opened", Some(on)) => {
		453	let title = format!("{who} opened {at}");
		454	for name in &on.assignees {
		455	told.tell(name, Reason::Assign, Severity::Info, &format!("{who} assigned you to {at}"), &on.title, true);
		456	}
		457	for name in &on.reviewers {
		458	told.tell(name, Reason::ReviewRequested, Severity::Warning, &format!("{who} asked you to review {at}"), &on.title, true);
		459	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		460	for name in &on.mentions {
		461	told.tell(name, Reason::Mention, Severity::Info, &format!("{who} mentioned you on {at}"), &on.title, true);
		462	}
		463	for team in &on.team_mentions {
		464	let title = format!("{who} mentioned @{} on {at}", team.team);
		465	for name in &team.members {
		466	told.tell(name, Reason::TeamMention, Severity::Info, &title, &on.title, true);
		467	}
		468	}
Inbox: threads, reasons, subscriptions and watching2d ago		469	told.tell_watchers(activity_of(on), Severity::Info, &title, &on.title);
		470	}
Inbox: the events service tells people what needs them as events arrive2d ago		471	("checks.completed", Some(pull)) => {
		472	let title = match data["status"].as_str() {
Inbox: threads, reasons, subscriptions and watching2d ago		473	Some("errored") => format!("Checks could not run on {at}"),
		474	_ => format!("Checks failed on {at}"),
Inbox: the events service tells people what needs them as events arrive2d ago		475	};
Inbox: threads, reasons, subscriptions and watching2d ago		476	told.tell_person(pull.owner(), Reason::CiActivity, Severity::Error, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive2d ago		477	}
		478	("workflow.completed", subject) => {
		479	let workflow = data["workflow"].as_str().filter(|name| !name.is_empty()).unwrap_or("A workflow");
		480	match subject {
		481	Some(pull) => {
Inbox: threads, reasons, subscriptions and watching2d ago		482	let title = format!("{workflow} failed on {at}");
		483	told.tell_person(pull.owner(), Reason::CiActivity, Severity::Error, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive2d ago		484	}
		485	None => {
		486	// Not on a pull request: whoever pushed the commit it ran on.
		487	let branch = data["ref"].as_str().unwrap_or_default();
		488	let branch = branch.strip_prefix("refs/heads/").unwrap_or(branch);
		489	let title = format!("{workflow} failed on {branch} in {repo}");
		490	let body = format!("Run {} at {}", data["number"], short(data["sha"].as_str().unwrap_or_default()));
		491	if let Some(id) = &actor.id
		492	&& !is_g1t_id(id)
		493	&& let Some(name) = &actor.username
		494	{
Inbox: threads, reasons, subscriptions and watching2d ago		495	told.tell(name, Reason::CiActivity, Severity::Error, &title, &body, true);
		496	}
		497	}
		498	}
		499	}
		500	("deployment.failed" | "deployment.succeeded", subject) => {
		501	let failed = event.kind == "deployment.failed";
		502	let project = data["project"].as_str().filter(|name| !name.is_empty()).unwrap_or(repo);
		503	let what = match subject {
		504	Some(_) => format!("The preview of {at}"),
		505	None => format!("Production of {project}"),
		506	};
		507	let (title, severity) = if failed {
		508	(format!("{what} failed to deploy"), Severity::Error)
		509	} else {
		510	(format!("{what} is live"), Severity::Success)
		511	};
		512	let body = match (failed, data["error"].as_str().map(str::trim).filter(|error| !error.is_empty())) {
		513	(true, Some(error)) => error.to_owned(),
		514	_ => match subject {
		515	Some(pull) => pull.title.clone(),
		516	None => format!("Commit {}", short(data["commit"].as_str().unwrap_or_default())),
		517	},
		518	};
		519	// A success is news to whoever answers for it only after a failure.
		520	if failed || data["recovered"].as_bool() == Some(true) {
		521	let title = if failed { title.clone() } else { format!("{what} is live again") };
		522	match subject {
		523	Some(pull) => told.tell_person(pull.owner(), Reason::CiActivity, severity, &title, &body, true),
		524	None => {
		525	let pusher = actor
		526	.id
		527	.as_deref()
		528	.filter(|id| !is_g1t_id(id))
		529	.and(actor.username.as_deref())
		530	.or_else(|| data["triggeredBy"].as_str());
		531	if let Some(name) = pusher {
		532	told.tell(name, Reason::CiActivity, severity, &title, &body, true);
		533	}
Inbox: the events service tells people what needs them as events arrive2d ago		534	}
		535	}
		536	}
Inbox: threads, reasons, subscriptions and watching2d ago		537	told.tell_watchers("deployments", severity, &title, &body);
Inbox: the events service tells people what needs them as events arrive2d ago		538	}
		539	("review.completed", Some(pull)) => {
Inbox: threads, reasons, subscriptions and watching2d ago		540	let (title, severity) = match data["verdict"].as_str() {
		541	Some("approve") => (format!("g1t approved {at}"), Severity::Success),
		542	_ => (format!("g1t asked for changes on {at}"), Severity::Info),
Inbox: the events service tells people what needs them as events arrive2d ago		543	};
Inbox: threads, reasons, subscriptions and watching2d ago		544	told.tell_person(pull.owner(), Reason::Author, severity, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive2d ago		545	}
		546	("pull.ready", Some(pull)) => {
		547	// A change g1t made is ready: the agent's run is over.
		548	if let Some(owner) = pull.requested_by.as_ref().filter(|_| is_g1t_id(&pull.author.id) || is_g1t(&pull.author.username)) {
Inbox: threads, reasons, subscriptions and watching2d ago		549	let title = format!("g1t finished {at}");
		550	told.tell_person(owner, Reason::Author, Severity::Success, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive2d ago		551	}
		552	}
Inbox: threads, reasons, subscriptions and watching2d ago		553	("pull.merged" | "pull.closed" | "issue.closed" | "issue.reopened", Some(on)) => {
		554	let (verb, severity) = match event.kind.as_str() {
		555	"pull.merged" => ("merged", Severity::Success),
		556	"issue.reopened" => ("reopened", Severity::Info),
		557	_ => ("closed", Severity::Info),
		558	};
		559	let title = match (actor.name(), data["resolvedBy"].as_u64()) {
		560	(_, Some(pull)) if event.kind == "issue.closed" => format!("{at} was closed by #{pull}"),
		561	(Some(name), _) => format!("{name} {verb} {at}"),
		562	(None, _) => format!("{at} was {verb}"),
Inbox: the events service tells people what needs them as events arrive2d ago		563	};
Inbox: threads, reasons, subscriptions and watching2d ago		564	told.tell_subscribed(on, Some(Reason::StateChange), severity, &title, &on.title);
		565	told.tell_watchers(activity_of(on), severity, &title, &on.title);
Inbox: the events service tells people what needs them as events arrive2d ago		566	}
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		567	("deployment.review_requested", _) => {
		568	let environment = data["environment"].as_str().unwrap_or("an environment");
		569	let workflow = data["workflow"].as_str().unwrap_or("A workflow");
		570	let title = format!("{workflow} is waiting for your review to deploy to {environment} in {repo}");
		571	let body = data["title"].as_str().unwrap_or_default();
		572	// Those the actions service names: the environment's reviewers.
		573	for name in names(data, "notify") {
		574	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, body, true);
		575	}
		576	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		577	(kind, None) if SECURITY_EVENTS.contains(&kind) => {
		578	let severity = match data["severity"].as_str() {
		579	_ if kind == "secret_scanning.bypass_requested" => Severity::Warning,
		580	_ if kind == "secret_scanning.bypass_reviewed" => Severity::Info,
		581	Some("critical" | "high") => Severity::Error,
		582	_ => Severity::Warning,
		583	};
		584	let what = data["title"].as_str().unwrap_or("A security alert");
		585	let title = match kind {
		586	"secret_scanning.bypass_requested" => format!("{who} asked to bypass push protection in {repo}"),
		587	"secret_scanning.bypass_reviewed" => {
		588	let verdict = data["state"].as_str().unwrap_or("reviewed");
		589	format!("Your request to bypass push protection in {repo} was {verdict}")
		590	}
		591	_ if data["pusher"].is_string() => format!("A push to {repo} was blocked: it adds a secret"),
		592	_ => format!("New security alert in {repo}"),
		593	};
		594	// Whoever pushed a blocked secret, and those the service names
		595	// (the workspace's owners, or whoever asked for a bypass).
		596	if let Some(pusher) = data["pusher"].as_str() {
		597	told.tell(pusher, Reason::SecurityAlert, Severity::Error, &title, what, true);
		598	}
		599	for name in names(data, "notify") {
		600	told.tell(&name, Reason::SecurityAlert, severity, &title, what, true);
		601	}
		602	// Watchers who chose security alerts, if they may see findings:
		603	// the service lists who may (`members`), as findings are never
		604	// shown to someone who cannot change the code.
		605	if !kind.starts_with("secret_scanning.bypass") {
		606	let members = names(data, "members");
		607	let watching: Vec<String> = told.audience.watching("security").collect();
		608	for name in watching.iter().filter(|name| members.iter().any(|member| member.eq_ignore_ascii_case(name))) {
		609	told.tell(name, Reason::SecurityAlert, severity, &title, what, false);
		610	}
		611	}
		612	}
Inbox: the events service tells people what needs them as events arrive2d ago		613	("comment.created", Some(on)) => {
		614	let Some(comment) = on.comment.as_ref().filter(|comment| !comment.event) else {
		615	return Vec::new();
		616	};
		617	// Whoever wrote it is the actor, whatever the event says.
		618	let writer = Actor {
		619	id: Some(comment.author.id.clone()),
		620	username: Some(comment.author.username.clone()),
		621	};
		622	told.actor = &writer;
		623	let who = &comment.author.username;
		624	let body = if comment.excerpt.is_empty() { &on.title } else { &comment.excerpt };
		625	for name in &comment.mentions {
Inbox: threads, reasons, subscriptions and watching2d ago		626	let title = format!("{who} mentioned you on {at}");
		627	told.tell(name, Reason::Mention, Severity::Info, &title, body, true);
Inbox: the events service tells people what needs them as events arrive2d ago		628	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		629	for team in &comment.team_mentions {
		630	let title = format!("{who} mentioned @{} on {at}", team.team);
		631	for name in &team.members {
		632	told.tell(name, Reason::TeamMention, Severity::Info, &title, body, true);
		633	}
		634	}
Inbox: threads, reasons, subscriptions and watching2d ago		635	let (severity, title) = match comment.verdict.as_deref() {
		636	Some("approve") => (Severity::Success, format!("{who} approved {at}")),
		637	Some("request_changes") => (Severity::Info, format!("{who} asked for changes on {at}")),
		638	_ => (Severity::Info, format!("{who} commented on {at}")),
Inbox: the events service tells people what needs them as events arrive2d ago		639	};
Inbox: threads, reasons, subscriptions and watching2d ago		640	// An approval or a request for changes is the owner's to hear
		641	// of whatever they chose; the rest, as they subscribed.
		642	if comment.verdict.is_some() {
		643	told.tell_person(on.owner(), Reason::Author, severity, &title, body, true);
		644	}
		645	told.tell_subscribed(on, None, severity, &title, body);
		646	told.tell_watchers(activity_of(on), severity, &title, body);
Inbox: the events service tells people what needs them as events arrive2d ago		647	return told.notices;
		648	}
		649	_ => {}
		650	}
		651	told.notices
		652	}
		653
Inbox: threads, reasons, subscriptions and watching2d ago		654	/// Who an event subscribes to its issue or pull request without asking,
		655	/// and why: whoever commented, whoever they mentioned, the people assigned
		656	/// and the reviewers asked. Never g1t.
		657	pub fn subscribes(event: &Event, subject: Option<&InboxSubject>) -> Vec<(String, Reason)> {
		658	let mut people: Vec<(String, Reason)> = Vec::new();
		659	let mut add = |name: &str, reason: Reason| {
		660	let name = name.trim().trim_start_matches('@').to_lowercase();
		661	if !name.is_empty() && !is_g1t(&name) && !people.iter().any(|(had, _)| *had == name) {
		662	people.push((name, reason));
		663	}
		664	};
		665	match event.kind.as_str() {
		666	"comment.created" => {
		667	if let Some(comment) = subject.and_then(|subject| subject.comment.as_ref()).filter(|comment| !comment.event) {
		668	if !is_g1t_id(&comment.author.id) {
		669	add(&comment.author.username, Reason::Comment);
		670	}
		671	for name in &comment.mentions {
		672	add(name, Reason::Mention);
		673	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		674	for team in &comment.team_mentions {
		675	for name in &team.members {
		676	add(name, Reason::TeamMention);
		677	}
		678	}
		679	}
		680	}
		681	"issue.opened" | "pull.opened" => {
		682	if let Some(on) = subject {
		683	for name in &on.mentions {
		684	add(name, Reason::Mention);
		685	}
		686	for team in &on.team_mentions {
		687	for name in &team.members {
		688	add(name, Reason::TeamMention);
		689	}
		690	}
Inbox: threads, reasons, subscriptions and watching2d ago		691	}
		692	}
		693	"issue.assigned" | "pull.assigned" => {
		694	for name in names(&event.data, "added") {
		695	add(&name, Reason::Assign);
		696	}
		697	}
		698	"pull.review_requested" => {
		699	for name in names(&event.data, "reviewers") {
		700	add(&name, Reason::ReviewRequested);
		701	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		702	for (_, people) in teams_asked(&event.data) {
		703	for name in people {
		704	add(&name, Reason::ReviewRequested);
		705	}
		706	}
Inbox: threads, reasons, subscriptions and watching2d ago		707	}
		708	_ => {}
		709	}
		710	people
		711	}
		712
Inbox: the events service tells people what needs them as events arrive2d ago		713	fn short(sha: &str) -> &str {
		714	sha.get(..7).unwrap_or(sha)
		715	}
		716
		717	/// Where an item is on g1t.sh.
Inbox: threads, reasons, subscriptions and watching2d ago		718	pub fn url(repo: Option<&str>, subject: Option<SubjectKind>, number: Option<u32>, run_id: Option<&str>, link: Option<&str>) -> String {
		719	if let Some(link) = link.filter(|link| link.starts_with('/')) {
		720	return link.to_owned();
		721	}
Inbox: the events service tells people what needs them as events arrive2d ago		722	let Some(repo) = repo else {
		723	return "/inbox".to_owned();
		724	};
		725	match (subject, number, run_id) {
		726	(Some(SubjectKind::Pull), Some(number), _) => format!("/{repo}/pull/{number}"),
		727	(Some(SubjectKind::Issue), Some(number), _) => format!("/{repo}/issues/{number}"),
		728	(Some(SubjectKind::Run), _, Some(run)) => format!("/{repo}/actions/runs/{run}"),
Inbox: threads, reasons, subscriptions and watching2d ago		729	(Some(SubjectKind::Deploy), Some(number), _) => format!("/{repo}/pull/{number}"),
Inbox: the events service tells people what needs them as events arrive2d ago		730	_ => format!("/{repo}"),
		731	}
		732	}
		733
		734	// --- Writing ---------------------------------------------------------------
		735
		736	/// The services the inbox reads from as events arrive.
		737	pub struct Sources<'a> {
		738	pub work: &'a Fetcher,
		739	pub repos: &'a Fetcher,
		740	pub identity: &'a Fetcher,
		741	}
		742
Inbox: threads, reasons, subscriptions and watching2d ago		743	/// One notice written, and whether it was news (not a redelivery): what
		744	/// may be emailed.
		745	struct Written {
		746	notice: Notice,
		747	repo_id: String,
		748	url: String,
		749	}
		750
Inbox: the events service tells people what needs them as events arrive2d ago		751	/// Writes the items a batch from the bus calls for. Never fails the batch:
		752	/// what cannot be worked out is logged and left.
		753	pub async fn deliver(db: &D1Database, sources: &Sources<'_>, events: &[Event]) {
Inbox: threads, reasons, subscriptions and watching2d ago		754	if let Err(error) = resolve(db, events).await {
		755	worker::console_error!("inbox: agent threads not closed: {error}");
		756	}
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		757	// A workspace's own notices, about no repository (workspace_notices).
		758	for event in events.iter().filter(|event| WORKSPACE_EVENTS.contains(&event.kind.as_str())) {
		759	if let Err(error) = deliver_workspace(db, event).await {
		760	worker::console_error!("inbox: {} {} not delivered: {error}", event.kind, event.id);
		761	}
		762	}
Inbox: the events service tells people what needs them as events arrive2d ago		763	let wanted: Vec<(&Event, Wanted)> = events
		764	.iter()
		765	.filter_map(|event| wants(event).map(|wanted| (event, wanted)))
		766	.collect();
Inbox: threads, reasons, subscriptions and watching2d ago		767	let created: Vec<&Event> = events.iter().filter(|event| event.kind == "repo.created").collect();
		768	if wanted.is_empty() && created.is_empty() {
Inbox: the events service tells people what needs them as events arrive2d ago		769	return;
		770	}
		771	// Everyone who caused one, named in one call.
		772	let ids: Vec<String> = wanted
		773	.iter()
Inbox: threads, reasons, subscriptions and watching2d ago		774	.map(|(event, _)| *event)
		775	.chain(created.iter().copied())
		776	.filter_map(|event| event.actor.clone())
Inbox: the events service tells people what needs them as events arrive2d ago		777	.filter(|id| !is_g1t_id(id))
		778	.collect::<HashSet<_>>()
		779	.into_iter()
		780	.collect();
		781	let names: HashMap<String, String> = if ids.is_empty() {
		782	HashMap::new()
		783	} else {
		784	g1t_kit::call(sources.identity, "usernames", &UsernamesArgs { ids })
		785	.await
		786	.unwrap_or_else(|error| {
		787	worker::console_error!("inbox: could not name who acted: {error}");
		788	HashMap::new()
		789	})
		790	};
Inbox: threads, reasons, subscriptions and watching2d ago		791	for event in created {
		792	if let Err(error) = subscriptions::watch_created(db, event, &names).await {
		793	worker::console_error!("inbox: {} {} not watched: {error}", event.kind, event.id);
		794	}
		795	}
Inbox: the events service tells people what needs them as events arrive2d ago		796	let mut paths: HashMap<String, Option<RepoPath>> = HashMap::new();
Inbox: threads, reasons, subscriptions and watching2d ago		797	let mut watchers: HashMap<String, Vec<subscriptions::Watcher>> = HashMap::new();
		798	let mut written: Vec<Written> = Vec::new();
Inbox: the events service tells people what needs them as events arrive2d ago		799	for (event, wanted) in wanted {
Inbox: threads, reasons, subscriptions and watching2d ago		800	match deliver_one(db, sources, &names, &mut paths, &mut watchers, event, wanted).await {
		801	Ok(mut news) => written.append(&mut news),
		802	Err(error) => worker::console_error!("inbox: {} {} not delivered: {error}", event.kind, event.id),
		803	}
		804	}
		805	if let Err(error) = email(db, sources.identity, written).await {
		806	worker::console_error!("inbox: emails not sent: {error}");
		807	}
		808	}
		809
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		810	/// Events about a workspace rather than a repository, each naming who to
		811	/// tell (`notify`), what to say (`title`, `body`) and where it is (`link`):
		812	/// identity's personal access token approvals.
		813	///
		814	/// | Event | Who | Reason | Severity |
		815	/// | --- | --- | --- | --- |
		816	/// | `token.approval_requested` | the workspace's owners | review_requested | warning |
		817	/// | `token.approval_reviewed` | the token's owner | author | info |
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		818	/// | `workspace_invitation.created` | the person invited | review_requested | warning |
		819	/// | `workspace_invitation.accepted` | who invited them | author | success |
		820	/// | `workspace_invitation.declined` | who invited them | author | info |
		821	///
		822	/// An invitation's item for the person invited is done once it is
		823	/// accepted, declined or revoked (`workspace_invitation.revoked`, which
		824	/// tells nobody).
		825	pub const WORKSPACE_EVENTS: [&str; 5] = [
		826	"token.approval_requested",
		827	"token.approval_reviewed",
		828	"workspace_invitation.created",
		829	"workspace_invitation.accepted",
		830	"workspace_invitation.declined",
		831	];
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		832
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		833	/// Events that close what a workspace invitation asked of its person.
		834	pub const INVITATION_ANSWERED: [&str; 3] =
		835	["workspace_invitation.accepted", "workspace_invitation.declined", "workspace_invitation.revoked"];
		836
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		837	/// The notices a workspace event calls for, and the thread they go to.
		838	pub fn workspace_notices(event: &Event, actor: Option<&str>) -> (String, Vec<Notice>) {
		839	let data = &event.data;
		840	let text = |key: &str| data[key].as_str().unwrap_or_default().to_owned();
		841	let (reason, severity) = match event.kind.as_str() {
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		842	"token.approval_requested" | "workspace_invitation.created" => (Reason::ReviewRequested, Severity::Warning),
		843	"workspace_invitation.accepted" => (Reason::Author, Severity::Success),
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		844	_ => (Reason::Author, Severity::Info),
		845	};
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		846	// An invitation names its own thread; a token approval's is the token's.
		847	let thread = match data["thread"].as_str().filter(|thread| !thread.is_empty()) {
		848	Some(thread) => thread.to_owned(),
		849	None => format!("workspace:{}/token/{}", text("workspace"), text("tokenId")),
		850	};
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		851	let notices = names(data, "notify")
		852	.into_iter()
		853	.map(|name| name.to_lowercase())
		854	.filter(|name| actor.is_none_or(|actor| !actor.eq_ignore_ascii_case(name)) && !is_g1t(name))
		855	.collect::<HashSet<_>>()
		856	.into_iter()
		857	.map(|username| Notice { username, reason, severity, title: text("title"), body: text("body") })
		858	.collect();
		859	(thread, notices)
		860	}
		861
		862	/// Writes a workspace event's notices: a thread each, with no repository.
		863	async fn deliver_workspace(db: &D1Database, event: &Event) -> Result<()> {
		864	let (thread, told) = workspace_notices(event, None);
		865	if told.is_empty() {
		866	return Ok(());
		867	}
		868	let now = now_ms();
		869	let workspace = event.data["workspace"].as_str().unwrap_or_default().to_lowercase();
		870	let link = event.data["link"].as_str().filter(|link| link.starts_with('/'));
		871	let mut statements = Vec::new();
		872	for notice in &told {
		873	let username = notice.username.as_str();
		874	statements.push(db.prepare(BUMP).bind(&[
		875	new_id("ntf", now).into(),
		876	username.into(),
		877	thread.as_str().into(),
		878	event.id.as_str().into(),
		879	event.kind.as_str().into(),
		880	notice.reason.as_str().into(),
		881	notice.severity.as_str().into(),
		882	notice.title.as_str().into(),
		883	notice.body.as_str().into(),
		884	workspace.as_str().into(),
		885	JsValue::NULL,
		886	JsValue::NULL,
		887	JsValue::NULL,
		888	JsValue::NULL,
		889	JsValue::NULL,
		890	link.map_or(JsValue::NULL, JsValue::from),
		891	JsValue::NULL,
		892	event.time.as_str().into(),
		893	new_id("ntf", now).into(),
		894	])?);
		895	statements.push(
		896	db.prepare(
		897	"INSERT OR IGNORE INTO inbox_activity (id, item_id, username, event_id, event, reason, severity, title, body, actor, created_at)
		898	SELECT ?1, id, ?2, ?4, ?5, ?6, ?7, ?8, ?9, NULL, ?10 FROM inbox_items WHERE username = ?2 AND thread = ?3",
		899	)
		900	.bind(&[
		901	new_id("ntf", now).into(),
		902	username.into(),
		903	thread.as_str().into(),
		904	event.id.as_str().into(),
		905	event.kind.as_str().into(),
		906	notice.reason.as_str().into(),
		907	notice.severity.as_str().into(),
		908	notice.title.as_str().into(),
		909	notice.body.as_str().into(),
		910	event.time.as_str().into(),
		911	])?,
		912	);
		913	}
		914	db.batch(statements).await?;
		915	Ok(())
		916	}
		917
Inbox: threads, reasons, subscriptions and watching2d ago		918	/// Closes what an agent was waiting on a person for once it is over.
		919	async fn resolve(db: &D1Database, events: &[Event]) -> Result<()> {
		920	let now = rfc3339(now_ms());
		921	let mut statements = Vec::new();
		922	for thread in events.iter().filter_map(resolves) {
		923	statements.push(
		924	db.prepare(
		925	"UPDATE inbox_items SET done_at = ?1, read_at = COALESCE(read_at, ?1)
		926	WHERE thread = ?2 AND reason = 'agent' AND done_at IS NULL",
		927	)
		928	.bind(&[now.as_str().into(), thread.into()])?,
		929	);
		930	}
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		931	// A workspace invitation answered or revoked no longer waits on its person.
		932	for event in events.iter().filter(|event| INVITATION_ANSWERED.contains(&event.kind.as_str())) {
		933	let Some(thread) = event.data["thread"].as_str().filter(|thread| thread.starts_with("invitation:")) else {
		934	continue;
		935	};
		936	statements.push(
		937	db.prepare(
		938	"UPDATE inbox_items SET done_at = ?1, read_at = COALESCE(read_at, ?1)
		939	WHERE thread = ?2 AND reason = 'review_requested' AND done_at IS NULL",
		940	)
		941	.bind(&[now.as_str().into(), thread.into()])?,
		942	);
		943	}
Inbox: threads, reasons, subscriptions and watching2d ago		944	// Reviews no longer asked for are no longer waiting.
		945	for event in events.iter().filter(|event| event.kind == "pull.review_request_removed") {
		946	let (Some(repo_id), Some(number)) = (
		947	event.data["repoId"].as_str().map(str::to_owned).or_else(|| event.repo_id.clone()),
		948	event.data["number"].as_u64(),
		949	) else {
		950	continue;
		951	};
		952	for name in names(&event.data, "reviewers") {
		953	statements.push(
		954	db.prepare(
		955	"UPDATE inbox_items SET done_at = ?1, read_at = COALESCE(read_at, ?1)
		956	WHERE thread = ?2 AND username = ?3 AND reason = 'review_requested' AND done_at IS NULL",
		957	)
		958	.bind(&[
		959	now.as_str().into(),
		960	format!("{repo_id}#{number}").into(),
		961	name.to_lowercase().into(),
		962	])?,
		963	);
Inbox: the events service tells people what needs them as events arrive2d ago		964	}
		965	}
Inbox: threads, reasons, subscriptions and watching2d ago		966	if !statements.is_empty() {
		967	db.batch(statements).await?;
		968	}
		969	Ok(())
Inbox: the events service tells people what needs them as events arrive2d ago		970	}
		971
		972	async fn deliver_one(
		973	db: &D1Database,
		974	sources: &Sources<'_>,
		975	names: &HashMap<String, String>,
		976	paths: &mut HashMap<String, Option<RepoPath>>,
Inbox: threads, reasons, subscriptions and watching2d ago		977	watchers: &mut HashMap<String, Vec<subscriptions::Watcher>>,
Inbox: the events service tells people what needs them as events arrive2d ago		978	event: &Event,
		979	wanted: Wanted,
Inbox: threads, reasons, subscriptions and watching2d ago		980	) -> Result<Vec<Written>> {
Inbox: the events service tells people what needs them as events arrive2d ago		981	if !paths.contains_key(&wanted.repo_id) {
		982	let path: Option<RepoPath> = g1t_kit::call(
		983	sources.repos,
		984	"path_by_id",
		985	&PathByIdArgs {
		986	id: wanted.repo_id.clone(),
		987	},
		988	)
		989	.await?;
		990	paths.insert(wanted.repo_id.clone(), path);
		991	}
		992	// A repository that is gone tells nobody.
		993	let Some(path) = paths.get(&wanted.repo_id).cloned().flatten() else {
Inbox: threads, reasons, subscriptions and watching2d ago		994	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive2d ago		995	};
		996	let subject: Option<InboxSubject> = match wanted.number {
		997	Some(number) => {
		998	let found: Option<InboxSubject> = g1t_kit::call(
		999	sources.work,
		1000	"inbox_subject",
		1001	&InboxSubjectArgs {
		1002	repo_id: wanted.repo_id.clone(),
		1003	number,
		1004	comment_id: wanted.comment_id.clone(),
		1005	},
		1006	)
		1007	.await?;
		1008	if found.is_none() {
Inbox: threads, reasons, subscriptions and watching2d ago		1009	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive2d ago		1010	}
		1011	found
		1012	}
		1013	None => None,
		1014	};
		1015	let actor = Actor {
		1016	id: event.actor.clone(),
		1017	username: match event.actor.as_deref() {
		1018	Some(id) if is_g1t_id(id) => Some(system::USERNAME.to_owned()),
		1019	Some(id) => names.get(id).map(|name| name.to_lowercase()),
		1020	None => None,
		1021	},
		1022	};
Inbox: threads, reasons, subscriptions and watching2d ago		1023	let thread = thread_of(event, &wanted, subject.as_ref());
		1024	if !watchers.contains_key(&wanted.repo_id) {
		1025	watchers.insert(wanted.repo_id.clone(), subscriptions::watchers(db, &wanted.repo_id).await?);
		1026	}
		1027	let audience = Audience {
		1028	subscriptions: match thread.kind {
		1029	Some(SubjectKind::Issue | SubjectKind::Pull) => subscriptions::of_thread(db, &thread.key).await?,
		1030	_ => Vec::new(),
		1031	},
		1032	watchers: watchers.get(&wanted.repo_id).cloned().unwrap_or_default(),
		1033	};
Inbox: the events service tells people what needs them as events arrive2d ago		1034	let repo = format!("{}/{}", path.namespace, path.name).to_lowercase();
Inbox: threads, reasons, subscriptions and watching2d ago		1035	let told = notices(event, &repo, &actor, subject.as_ref(), &audience);
		1036	let mut statements = subscriptions::auto_subscribe(db, &thread.key, &wanted.repo_id, &subscribes(event, subject.as_ref()), &event.time)?;
Inbox: the events service tells people what needs them as events arrive2d ago		1037	if told.is_empty() {
Inbox: threads, reasons, subscriptions and watching2d ago		1038	if !statements.is_empty() {
		1039	db.batch(statements).await?;
		1040	}
		1041	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive2d ago		1042	}
		1043	let now = now_ms();
Inbox: threads, reasons, subscriptions and watching2d ago		1044	let link = thread.link.as_deref();
		1045	let item_url = url(Some(&repo), thread.kind, thread.number, thread.run_id.as_deref(), link);
		1046	// Three statements a notice: its thread brought up (unless this event
		1047	// was told before), a line of history, and the history kept short.
		1048	let first = statements.len();
		1049	for notice in &told {
		1050	let username = notice.username.as_str();
		1051	let values: Vec<JsValue> = vec![
		1052	new_id("ntf", now).into(),
		1053	username.into(),
		1054	thread.key.as_str().into(),
		1055	event.id.as_str().into(),
		1056	event.kind.as_str().into(),
		1057	notice.reason.as_str().into(),
		1058	notice.severity.as_str().into(),
		1059	notice.title.as_str().into(),
		1060	notice.body.as_str().into(),
		1061	path.namespace.to_lowercase().into(),
		1062	wanted.repo_id.as_str().into(),
		1063	repo.as_str().into(),
		1064	thread.kind.map_or(JsValue::NULL, |kind| kind.as_str().into()),
		1065	thread.number.map_or(JsValue::NULL, JsValue::from),
		1066	thread.run_id.as_deref().map_or(JsValue::NULL, JsValue::from),
		1067	link.map_or(JsValue::NULL, JsValue::from),
		1068	actor.username.as_deref().map_or(JsValue::NULL, JsValue::from),
		1069	event.time.as_str().into(),
		1070	// Same prefix as item ids, so old and new sort by time together.
		1071	new_id("ntf", now).into(),
		1072	];
		1073	statements.push(db.prepare(BUMP).bind(&values)?);
Inbox: the events service tells people what needs them as events arrive2d ago		1074	statements.push(
		1075	db.prepare(
Inbox: threads, reasons, subscriptions and watching2d ago		1076	"INSERT OR IGNORE INTO inbox_activity (id, item_id, username, event_id, event, reason, severity, title, body, actor, created_at)
		1077	SELECT ?1, id, ?2, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11 FROM inbox_items WHERE username = ?2 AND thread = ?3
		1078	RETURNING username",
Inbox: the events service tells people what needs them as events arrive2d ago		1079	)
		1080	.bind(&[
		1081	new_id("ntf", now).into(),
Inbox: threads, reasons, subscriptions and watching2d ago		1082	username.into(),
		1083	thread.key.as_str().into(),
Inbox: the events service tells people what needs them as events arrive2d ago		1084	event.id.as_str().into(),
Inbox: threads, reasons, subscriptions and watching2d ago		1085	event.kind.as_str().into(),
		1086	notice.reason.as_str().into(),
Inbox: the events service tells people what needs them as events arrive2d ago		1087	notice.severity.as_str().into(),
		1088	notice.title.as_str().into(),
		1089	notice.body.as_str().into(),
		1090	actor.username.as_deref().map_or(JsValue::NULL, JsValue::from),
		1091	event.time.as_str().into(),
		1092	])?,
		1093	);
Inbox: threads, reasons, subscriptions and watching2d ago		1094	statements.push(
		1095	db.prepare(
		1096	"DELETE FROM inbox_activity
		1097	WHERE item_id = (SELECT id FROM inbox_items WHERE username = ?1 AND thread = ?2)
		1098	AND id NOT IN (
		1099	SELECT a.id FROM inbox_activity a
		1100	WHERE a.item_id = (SELECT id FROM inbox_items WHERE username = ?1 AND thread = ?2)
		1101	ORDER BY a.id DESC LIMIT ?3)",
		1102	)
		1103	.bind(&[username.into(), thread.key.as_str().into(), MAX_ACTIVITY.into()])?,
		1104	);
		1105	}
		1106	let results = db.batch(statements).await?;
		1107	#[derive(Deserialize)]
		1108	struct Told {
		1109	username: String,
Inbox: the events service tells people what needs them as events arrive2d ago		1110	}
Inbox: threads, reasons, subscriptions and watching2d ago		1111	// A line of history written means the event is news to that person.
		1112	let mut news = HashSet::new();
		1113	for (at, _) in told.iter().enumerate() {
		1114	if let Some(result) = results.get(first + at * 3 + 1)
		1115	&& let Ok(rows) = result.results::<Told>()
		1116	{
		1117	news.extend(rows.into_iter().map(|row| row.username));
		1118	}
		1119	}
		1120	Ok(told
		1121	.into_iter()
		1122	.filter(|notice| news.contains(&notice.username))
		1123	.map(|notice| Written {
		1124	notice,
		1125	repo_id: wanted.repo_id.clone(),
		1126	url: item_url.clone(),
		1127	})
		1128	.collect())
		1129	}
		1130
		1131	/// Brings a person's thread up with new activity, or starts it. `?1` id,
		1132	/// `?2` username, `?3` thread, `?4` event id, `?5` event type, `?6` reason,
		1133	/// `?7` severity, `?8` title, `?9` body, `?10` workspace, `?11` repo id,
		1134	/// `?12` repo, `?13` subject, `?14` number, `?15` run id, `?16` link, `?17`
		1135	/// actor, `?18` time, `?19` the time-sortable id lists order by. Nothing
		1136	/// happens when the person was already told of this event. While the
		1137	/// thread is unread its most urgent severity is kept; done or not, it
		1138	/// comes back to the inbox. A snooze stands.
		1139	const BUMP: &str = "INSERT INTO inbox_items (id, username, thread, event_id, event, reason, severity, title, body,
		1140	workspace, repo_id, repo, subject, number, run_id, link, actor, created_at, updated_at, bumped, activity)
		1141	SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?18, ?19, 1
		1142	WHERE NOT EXISTS (SELECT 1 FROM inbox_activity WHERE event_id = ?4 AND username = ?2)
		1143	ON CONFLICT (username, thread) DO UPDATE SET
		1144	event_id = excluded.event_id,
		1145	event = excluded.event,
		1146	reason = excluded.reason,
		1147	severity = CASE
		1148	WHEN inbox_items.read_at IS NULL AND inbox_items.done_at IS NULL
		1149	AND (CASE inbox_items.severity WHEN 'warning' THEN 0 WHEN 'error' THEN 1 WHEN 'success' THEN 2 ELSE 3 END)
		1150	< (CASE excluded.severity WHEN 'warning' THEN 0 WHEN 'error' THEN 1 WHEN 'success' THEN 2 ELSE 3 END)
		1151	THEN inbox_items.severity ELSE excluded.severity END,
		1152	title = excluded.title,
		1153	body = excluded.body,
		1154	workspace = excluded.workspace,
		1155	repo = excluded.repo,
		1156	subject = COALESCE(excluded.subject, inbox_items.subject),
		1157	run_id = COALESCE(excluded.run_id, inbox_items.run_id),
		1158	link = COALESCE(excluded.link, inbox_items.link),
		1159	actor = excluded.actor,
		1160	updated_at = excluded.updated_at,
		1161	bumped = excluded.bumped,
		1162	activity = inbox_items.activity + 1,
		1163	read_at = NULL,
		1164	done_at = NULL";
		1165
		1166	/// Emails what was news to people who asked to be emailed for its reason.
		1167	/// Identity sends each, only to a confirmed address and only if the person
		1168	/// can still read the repository.
		1169	async fn email(db: &D1Database, identity: &Fetcher, written: Vec<Written>) -> Result<()> {
		1170	if written.is_empty() {
		1171	return Ok(());
		1172	}
		1173	let people: Vec<String> = written
		1174	.iter()
		1175	.map(|item| item.notice.username.clone())
		1176	.collect::<HashSet<_>>()
		1177	.into_iter()
		1178	.collect();
		1179	let settings = subscriptions::settings_of(db, &people).await?;
		1180	for item in written {
		1181	let wants = settings.get(&item.notice.username).map_or(&DEFAULT_EMAIL[..], |settings| &settings.email[..]);
		1182	if !wants.contains(&item.notice.reason) {
		1183	continue;
		1184	}
		1185	let sent: Result<bool> = g1t_kit::call(
		1186	identity,
		1187	"notify_by_email",
		1188	&NotifyByEmailArgs {
		1189	username: item.notice.username.clone(),
		1190	repo_id: item.repo_id.clone(),
		1191	subject: item.notice.title.clone(),
		1192	intro: item.notice.body.clone(),
		1193	quote: None,
		1194	path: item.url.clone(),
		1195	reason: item.notice.reason,
		1196	},
		1197	)
		1198	.await;
		1199	if let Err(error) = sent {
		1200	worker::console_error!("inbox: email to {} not sent: {error}", item.notice.username);
		1201	}
		1202	}
Inbox: the events service tells people what needs them as events arrive2d ago		1203	Ok(())
		1204	}
		1205
		1206	// --- Reading and changing ----------------------------------------------------
		1207
		1208	#[derive(Deserialize)]
Inbox: threads, reasons, subscriptions and watching2d ago		1209	pub(crate) struct Row {
		1210	pub(crate) id: String,
Inbox: the events service tells people what needs them as events arrive2d ago		1211	reason: String,
		1212	severity: String,
		1213	title: String,
		1214	body: String,
Inbox: threads, reasons, subscriptions and watching2d ago		1215	event: Option<String>,
Inbox: the events service tells people what needs them as events arrive2d ago		1216	workspace: Option<String>,
Inbox: threads, reasons, subscriptions and watching2d ago		1217	pub(crate) repo_id: Option<String>,
Inbox: the events service tells people what needs them as events arrive2d ago		1218	repo: Option<String>,
		1219	subject: Option<String>,
		1220	number: Option<f64>,
		1221	run_id: Option<String>,
Inbox: threads, reasons, subscriptions and watching2d ago		1222	link: Option<String>,
Inbox: the events service tells people what needs them as events arrive2d ago		1223	actor: Option<String>,
Inbox: threads, reasons, subscriptions and watching2d ago		1224	activity: Option<f64>,
Inbox: the events service tells people what needs them as events arrive2d ago		1225	created_at: String,
Inbox: threads, reasons, subscriptions and watching2d ago		1226	updated_at: Option<String>,
Inbox: the events service tells people what needs them as events arrive2d ago		1227	read_at: Option<String>,
		1228	done_at: Option<String>,
		1229	saved: f64,
		1230	snoozed_until: Option<String>,
Inbox: threads, reasons, subscriptions and watching2d ago		1231	bumped: Option<String>,
Inbox: the events service tells people what needs them as events arrive2d ago		1232	}
		1233
		1234	impl Row {
Inbox: threads, reasons, subscriptions and watching2d ago		1235	pub(crate) fn into_item(self) -> InboxItem {
Inbox: the events service tells people what needs them as events arrive2d ago		1236	let subject = self.subject.as_deref().and_then(SubjectKind::parse);
		1237	let number = self.number.map(|n| n as u32);
		1238	InboxItem {
Inbox: threads, reasons, subscriptions and watching2d ago		1239	url: url(self.repo.as_deref(), subject, number, self.run_id.as_deref(), self.link.as_deref()),
Inbox: the events service tells people what needs them as events arrive2d ago		1240	id: self.id,
Inbox: threads, reasons, subscriptions and watching2d ago		1241	reason: Reason::parse(&self.reason).unwrap_or(Reason::Subscribed),
Inbox: the events service tells people what needs them as events arrive2d ago		1242	severity: Severity::parse(&self.severity).unwrap_or(Severity::Info),
		1243	title: self.title,
		1244	body: self.body,
Inbox: threads, reasons, subscriptions and watching2d ago		1245	event: self.event,
Inbox: the events service tells people what needs them as events arrive2d ago		1246	repo: self.repo,
		1247	workspace: self.workspace,
		1248	subject,
		1249	number,
		1250	actor: self.actor,
Inbox: threads, reasons, subscriptions and watching2d ago		1251	count: self.activity.map_or(1, |n| n as u32),
		1252	updated_at: self.updated_at.unwrap_or_else(|| self.created_at.clone()),
Inbox: the events service tells people what needs them as events arrive2d ago		1253	created_at: self.created_at,
		1254	read_at: self.read_at,
		1255	done_at: self.done_at,
		1256	saved: self.saved != 0.0,
		1257	snoozed_until: self.snoozed_until,
		1258	}
		1259	}
		1260	}
		1261
Inbox: threads, reasons, subscriptions and watching2d ago		1262	pub(crate) const COLUMNS: &str = "id, reason, severity, title, body, event, workspace, repo_id, repo, subject, number, run_id,
		1263	link, actor, activity, created_at, updated_at, read_at, done_at, saved, snoozed_until, bumped";
Inbox: the events service tells people what needs them as events arrive2d ago		1264
		1265	/// The conditions that pick a view's items, after `username = ?1`; `?2` is now.
		1266	fn view_filter(view: InboxView) -> &'static str {
		1267	match view {
		1268	InboxView::Inbox => "done_at IS NULL AND (snoozed_until IS NULL OR snoozed_until <= ?2)",
		1269	InboxView::Saved => "saved = 1",
		1270	InboxView::Done => "done_at IS NOT NULL",
		1271	}
		1272	}
		1273
		1274	/// Whether a list ranks unread warnings first: the inbox itself, unfiltered.
		1275	fn ranked(a: &ListInboxArgs) -> bool {
Inbox: threads, reasons, subscriptions and watching2d ago		1276	a.view == InboxView::Inbox
		1277	&& a.severity.is_none()
		1278	&& a.reason.is_none()
		1279	&& !a.participating
		1280	&& a.repo_id.is_none()
		1281	&& !a.unread
		1282	&& a.since.is_none()
		1283	&& a.updated_before.is_none()
Inbox: the events service tells people what needs them as events arrive2d ago		1284	}
		1285
Inbox: threads, reasons, subscriptions and watching2d ago		1286	/// The conditions a list's filters add, and the values they bind, numbered
		1287	/// after the `bound` values already given.
		1288	fn filters(a: &ListInboxArgs, bound: usize) -> (Vec<String>, Vec<String>) {
		1289	let mut conditions = Vec::new();
		1290	let mut values: Vec<String> = Vec::new();
		1291	let mut bind = |value: &str, condition: &str| {
		1292	values.push(value.to_owned());
		1293	conditions.push(condition.replace('?', &format!("?{}", bound + values.len())));
		1294	};
		1295	if let Some(severity) = a.severity {
		1296	bind(severity.as_str(), "severity = ?");
		1297	}
		1298	if let Some(reason) = a.reason {
		1299	bind(reason.as_str(), "reason = ?");
		1300	}
		1301	if let Some(repo_id) = &a.repo_id {
		1302	bind(repo_id, "repo_id = ?");
		1303	}
		1304	if let Some(since) = &a.since {
		1305	bind(since.trim(), "COALESCE(updated_at, created_at) >= ?");
		1306	}
		1307	if let Some(before) = &a.updated_before {
		1308	bind(before.trim(), "COALESCE(updated_at, created_at) < ?");
		1309	}
		1310	if a.participating {
		1311	conditions.push("reason NOT IN ('manual', 'subscribed')".to_owned());
		1312	}
		1313	if a.unread {
		1314	conditions.push("read_at IS NULL".to_owned());
		1315	}
		1316	(conditions, values)
		1317	}
		1318
Inbox: the events service tells people what needs them as events arrive2d ago		1319	pub async fn list(db: &D1Database, repos: &Fetcher, a: ListInboxArgs) -> Result<InboxPage> {
		1320	let Some(viewer) = &a.viewer else {
		1321	return Ok(InboxPage::default());
		1322	};
		1323	let username = viewer.username.to_lowercase();
		1324	let now = rfc3339(now_ms());
		1325	let limit = a.limit.unwrap_or(DEFAULT_INBOX_PAGE).clamp(1, MAX_INBOX_PAGE);
		1326	let mut values: Vec<JsValue> = vec![username.as_str().into(), now.as_str().into()];
Inbox: threads, reasons, subscriptions and watching2d ago		1327	let mut conditions = vec!["username = ?1".to_owned(), view_filter(a.view).to_owned()];
		1328	let (filtered, bound) = filters(&a, values.len());
		1329	conditions.extend(filtered);
		1330	values.extend(bound.iter().map(|value| JsValue::from(value.as_str())));
Inbox: the events service tells people what needs them as events arrive2d ago		1331	let ranked = ranked(&a);
		1332	// Unread warnings lead the first page, and are left out of the rest.
		1333	let leading = "severity = 'warning' AND read_at IS NULL";
		1334	let mut rest = conditions.clone();
Inbox: threads, reasons, subscriptions and watching2d ago		1335	let mut rest_values = values.clone();
Inbox: the events service tells people what needs them as events arrive2d ago		1336	if ranked {
		1337	rest.push(format!("NOT ({leading})"));
		1338	}
		1339	if let Some(before) = &a.before {
Inbox: threads, reasons, subscriptions and watching2d ago		1340	rest_values.push(before.as_str().into());
		1341	rest.push(format!("bumped < ?{}", rest_values.len()));
Inbox: the events service tells people what needs them as events arrive2d ago		1342	}
Inbox: threads, reasons, subscriptions and watching2d ago		1343	rest_values.push((limit + 1).into());
		1344	let order = if a.view == InboxView::Done { "done_at DESC, bumped DESC" } else { "bumped DESC" };
Inbox: the events service tells people what needs them as events arrive2d ago		1345	let mut statements = vec![
		1346	db.prepare(format!(
		1347	"SELECT {COLUMNS} FROM inbox_items WHERE {} ORDER BY {order} LIMIT ?{}",
		1348	rest.join(" AND "),
Inbox: threads, reasons, subscriptions and watching2d ago		1349	rest_values.len()
Inbox: the events service tells people what needs them as events arrive2d ago		1350	))
Inbox: threads, reasons, subscriptions and watching2d ago		1351	.bind(&rest_values)?,
Inbox: the events service tells people what needs them as events arrive2d ago		1352	];
		1353	if ranked && a.before.is_none() {
		1354	statements.push(
		1355	db.prepare(format!(
Inbox: threads, reasons, subscriptions and watching2d ago		1356	"SELECT {COLUMNS} FROM inbox_items WHERE {} AND {leading} ORDER BY bumped DESC LIMIT ?3",
		1357	conditions.join(" AND ")
Inbox: the events service tells people what needs them as events arrive2d ago		1358	))
		1359	.bind(&[username.as_str().into(), now.as_str().into(), MAX_RANKED.into()])?,
		1360	);
		1361	}
		1362	let results = db.batch(statements).await?;
		1363	let mut rows = results.first().map(|result| result.results::<Row>()).transpose()?.unwrap_or_default();
		1364	let next = if rows.len() > limit as usize {
		1365	rows.truncate(limit as usize);
Inbox: threads, reasons, subscriptions and watching2d ago		1366	rows.last().map(|row| row.bumped.clone().unwrap_or_else(|| row.id.clone()))
Inbox: the events service tells people what needs them as events arrive2d ago		1367	} else {
		1368	None
		1369	};
		1370	let mut items: Vec<Row> = results.get(1).map(|result| result.results::<Row>()).transpose()?.unwrap_or_default();
		1371	items.extend(rows);
Inbox: threads, reasons, subscriptions and watching2d ago		1372	let items = readable_only(db, repos, &a.viewer, &username, items).await?;
		1373	Ok(InboxPage {
		1374	items: items.into_iter().map(Row::into_item).collect(),
		1375	next,
		1376	})
		1377	}
Inbox: the events service tells people what needs them as events arrive2d ago		1378
Inbox: threads, reasons, subscriptions and watching2d ago		1379	/// Rows about repositories the viewer can still read; the rest are
		1380	/// removed from their inbox as they are found.
		1381	pub(crate) async fn readable_only(db: &D1Database, repos: &Fetcher, viewer: &g1t_contracts::Viewer, username: &str, mut rows: Vec<Row>) -> Result<Vec<Row>> {
		1382	let ids: Vec<String> = rows
Inbox: the events service tells people what needs them as events arrive2d ago		1383	.iter()
		1384	.filter_map(|row| row.repo_id.clone())
		1385	.collect::<HashSet<_>>()
		1386	.into_iter()
		1387	.collect();
Inbox: threads, reasons, subscriptions and watching2d ago		1388	if ids.is_empty() {
		1389	return Ok(rows);
		1390	}
		1391	let readable: Vec<Repo> = g1t_kit::call(
		1392	repos,
		1393	"readable",
		1394	&ReadableArgs {
		1395	ids: ids.clone(),
		1396	viewer: viewer.clone(),
		1397	},
		1398	)
		1399	.await?;
		1400	let readable: HashSet<String> = readable.into_iter().map(|repo| repo.id).collect();
		1401	let gone: Vec<String> = ids.into_iter().filter(|id| !readable.contains(id)).collect();
		1402	if !gone.is_empty() {
		1403	forget(db, username, &gone).await?;
		1404	rows.retain(|row| row.repo_id.as_ref().is_none_or(|id| !gone.contains(id)));
Inbox: the events service tells people what needs them as events arrive2d ago		1405	}
Inbox: threads, reasons, subscriptions and watching2d ago		1406	Ok(rows)
Inbox: the events service tells people what needs them as events arrive2d ago		1407	}
		1408
		1409	/// Removes a person's items about repositories they cannot read.
		1410	async fn forget(db: &D1Database, username: &str, repo_ids: &[String]) -> Result<()> {
		1411	let marks = vec!["?"; repo_ids.len()].join(", ");
		1412	let mut values: Vec<JsValue> = vec![username.into()];
		1413	values.extend(repo_ids.iter().map(|id| JsValue::from(id.as_str())));
Inbox: threads, reasons, subscriptions and watching2d ago		1414	db.batch(vec![
		1415	db.prepare(format!(
		1416	"DELETE FROM inbox_activity WHERE item_id IN (SELECT id FROM inbox_items WHERE username = ? AND repo_id IN ({marks}))"
		1417	))
		1418	.bind(&values)?,
		1419	db.prepare(format!("DELETE FROM inbox_items WHERE username = ? AND repo_id IN ({marks})"))
		1420	.bind(&values)?,
		1421	])
		1422	.await?;
Inbox: the events service tells people what needs them as events arrive2d ago		1423	Ok(())
		1424	}
		1425
		1426	#[derive(Deserialize)]
		1427	struct CountRow {
		1428	severity: String,
		1429	n: f64,
		1430	}
		1431
		1432	pub async fn counts(db: &D1Database, a: InboxCountsArgs) -> Result<InboxCounts> {
		1433	let rows = db
		1434	.prepare(
		1435	"SELECT severity, count(*) AS n FROM inbox_items
		1436	WHERE username = ? AND read_at IS NULL AND done_at IS NULL
		1437	AND (snoozed_until IS NULL OR snoozed_until <= ?)
		1438	GROUP BY severity",
		1439	)
		1440	.bind(&[a.username.to_lowercase().into(), rfc3339(now_ms()).into()])?
		1441	.all()
		1442	.await?
		1443	.results::<CountRow>()?;
		1444	let mut counts = InboxCounts::default();
		1445	for row in rows {
		1446	let n = row.n as u32;
		1447	counts.unread += n;
		1448	match Severity::parse(&row.severity) {
		1449	Some(Severity::Error) => counts.error += n,
		1450	Some(Severity::Warning) => counts.warning += n,
		1451	Some(Severity::Success) => counts.success += n,
		1452	Some(Severity::Info) | None => counts.info += n,
		1453	}
		1454	}
		1455	Ok(counts)
		1456	}
		1457
		1458	/// The change a mark makes, as a `SET` clause; `?1` is now.
		1459	fn mark_change(mark: InboxMark) -> &'static str {
		1460	match mark {
		1461	InboxMark::Read => "read_at = COALESCE(read_at, ?1)",
		1462	InboxMark::Unread => "read_at = NULL",
		1463	InboxMark::Done => "done_at = ?1, read_at = COALESCE(read_at, ?1)",
		1464	InboxMark::Undone => "done_at = NULL",
		1465	InboxMark::Save => "saved = 1",
		1466	InboxMark::Unsave => "saved = 0",
		1467	InboxMark::Snooze => "snoozed_until = ?2, read_at = COALESCE(read_at, ?1)",
Inbox: threads, reasons, subscriptions and watching2d ago		1468	InboxMark::Unsnooze => "snoozed_until = NULL",
Inbox: the events service tells people what needs them as events arrive2d ago		1469	}
		1470	}
		1471
		1472	#[derive(Deserialize)]
		1473	struct IdRow {
		1474	#[allow(dead_code)]
		1475	id: String,
		1476	}
		1477
		1478	/// Changes the person's own items. Returns how many changed.
		1479	pub async fn mark(db: &D1Database, a: MarkInboxArgs) -> Result<u32> {
		1480	let now = rfc3339(now_ms());
		1481	let until = match (a.mark, a.until.as_deref().map(str::trim)) {
		1482	// Times compare as text (`g1t_contracts::time`); a snooze is for later.
		1483	(InboxMark::Snooze, Some(until)) if until.len() == now.len() && until > now.as_str() => until.to_owned(),
		1484	(InboxMark::Snooze, _) => return Ok(0),
		1485	_ => String::new(),
		1486	};
		1487	let mut values: Vec<JsValue> = vec![now.as_str().into(), until.as_str().into(), a.username.to_lowercase().into()];
		1488	let target = if a.all && a.ids.is_empty() {
		1489	let mut target = "done_at IS NULL".to_owned();
Inbox: threads, reasons, subscriptions and watching2d ago		1490	let mut bind = |values: &mut Vec<JsValue>, value: &str, condition: &str| {
		1491	values.push(value.into());
		1492	target.push_str(&format!(" AND {}", condition.replace('?', &format!("?{}", values.len()))));
		1493	};
Inbox: the events service tells people what needs them as events arrive2d ago		1494	if let Some(severity) = a.severity {
Inbox: threads, reasons, subscriptions and watching2d ago		1495	bind(&mut values, severity.as_str(), "severity = ?");
		1496	}
		1497	if let Some(repo_id) = &a.repo_id {
		1498	bind(&mut values, repo_id, "repo_id = ?");
		1499	}
		1500	if let Some(last_read_at) = a.last_read_at.as_deref().map(str::trim).filter(|at| !at.is_empty()) {
		1501	bind(&mut values, last_read_at, "COALESCE(updated_at, created_at) <= ?");
Inbox: the events service tells people what needs them as events arrive2d ago		1502	}
		1503	target
		1504	} else {
		1505	let ids: Vec<&String> = a.ids.iter().take(MAX_MARK).collect();
		1506	if ids.is_empty() {
		1507	return Ok(0);
		1508	}
		1509	let first = values.len() + 1;
		1510	values.extend(ids.iter().map(|id| JsValue::from(id.as_str())));
		1511	let marks: Vec<String> = (first..values.len() + 1).map(|at| format!("?{at}")).collect();
		1512	format!("id IN ({})", marks.join(", "))
		1513	};
		1514	let changed = db
		1515	.prepare(format!(
		1516	"UPDATE inbox_items SET {} WHERE username = ?3 AND {target} RETURNING id",
		1517	mark_change(a.mark)
		1518	))
		1519	.bind(&values)?
		1520	.all()
		1521	.await?
		1522	.results::<IdRow>()?;
		1523	Ok(changed.len() as u32)
		1524	}
		1525
Inbox: threads, reasons, subscriptions and watching2d ago		1526	#[derive(Deserialize)]
		1527	struct ActivityRow {
		1528	reason: String,
		1529	severity: String,
		1530	title: String,
		1531	body: String,
		1532	event: Option<String>,
		1533	actor: Option<String>,
		1534	created_at: String,
		1535	}
		1536
		1537	/// One of the viewer's threads, with its history and their subscription.
		1538	pub async fn thread(db: &D1Database, repos: &Fetcher, work: &Fetcher, a: ThreadArgs) -> Result<Option<InboxThread>> {
		1539	let Some(viewer) = &a.viewer else {
		1540	return Ok(None);
		1541	};
		1542	let username = viewer.username.to_lowercase();
		1543	let row = db
		1544	.prepare(format!("SELECT {COLUMNS} FROM inbox_items WHERE id = ? AND username = ?"))
		1545	.bind(&[a.id.as_str().into(), username.as_str().into()])?
		1546	.first::<Row>(None)
		1547	.await?;
		1548	let Some(row) = readable_only(db, repos, &a.viewer, &username, row.into_iter().collect()).await?.pop() else {
		1549	return Ok(None);
		1550	};
		1551	let activity = db
		1552	.prepare(
		1553	"SELECT reason, severity, title, body, event, actor, created_at FROM inbox_activity
		1554	WHERE item_id = ? ORDER BY id DESC LIMIT ?",
		1555	)
		1556	.bind(&[row.id.as_str().into(), MAX_ACTIVITY.into()])?
		1557	.all()
		1558	.await?
		1559	.results::<ActivityRow>()?
		1560	.into_iter()
		1561	.map(|row| InboxActivity {
		1562	reason: Reason::parse(&row.reason).unwrap_or(Reason::Subscribed),
		1563	severity: Severity::parse(&row.severity).unwrap_or(Severity::Info),
		1564	title: row.title,
		1565	body: row.body,
		1566	event: row.event,
		1567	actor: row.actor,
		1568	created_at: row.created_at,
		1569	})
		1570	.collect();
		1571	let item = row.into_item();
		1572	let subscription = match (item.subject, item.number) {
		1573	(Some(SubjectKind::Issue | SubjectKind::Pull), Some(_)) => {
		1574	subscriptions::subscription(
		1575	db,
		1576	work,
		1577	SubscriptionArgs {
		1578	viewer: a.viewer.clone(),
		1579	id: Some(item.id.clone()),
		1580	..SubscriptionArgs::default()
		1581	},
		1582	)
		1583	.await?
		1584	}
		1585	_ => None,
		1586	};
		1587	Ok(Some(InboxThread {
		1588	item,
		1589	activity,
		1590	subscription,
		1591	}))
		1592	}
		1593
Inbox: the events service tells people what needs them as events arrive2d ago		1594	// --- Keeping up ------------------------------------------------------------------
		1595
		1596	/// Moves rows with renamed workspaces and repositories, and drops those
Merge account deletion: soft delete for 30 days, staff restore and purge, ghost for what remains (identity 0037)1d ago		1597	/// of purged repositories, deleted workspaces and purged accounts.
Inbox: the events service tells people what needs them as events arrive2d ago		1598	pub async fn follow(db: &D1Database, events: &[Event]) -> Result<()> {
		1599	let mut statements = Vec::new();
		1600	for event in events {
		1601	let text = |key: &str| event.data[key].as_str().unwrap_or_default().to_lowercase();
		1602	match event.kind.as_str() {
		1603	"workspace.renamed" => {
		1604	let Ok(renamed) = serde_json::from_value::<WorkspaceRenamed>(event.data.clone()) else {
		1605	continue;
		1606	};
		1607	let (from, to) = (renamed.from.to_lowercase(), renamed.to.to_lowercase());
		1608	if from == to {
		1609	continue;
		1610	}
		1611	statements.push(
		1612	db.prepare(
Inbox: threads, reasons, subscriptions and watching2d ago		1613	"UPDATE inbox_items SET repo = ?2 || substr(repo, length(?1) + 1), workspace = ?2,
		1614	link = CASE WHEN link LIKE '/' || ?1 || '/%' THEN '/' || ?2 || substr(link, length(?1) + 2) ELSE link END
Inbox: the events service tells people what needs them as events arrive2d ago		1615	WHERE workspace = ?1",
		1616	)
		1617	.bind(&[from.as_str().into(), to.as_str().into()])?,
		1618	);
Inbox: threads, reasons, subscriptions and watching2d ago		1619	statements.push(
		1620	db.prepare("UPDATE inbox_watching SET repo = ?2 || substr(repo, length(?1) + 1) WHERE repo LIKE ?1 || '/%'")
		1621	.bind(&[from.as_str().into(), to.as_str().into()])?,
		1622	);
Inbox: the events service tells people what needs them as events arrive2d ago		1623	}
Inbox: threads, reasons, subscriptions and watching2d ago		1624	"repo.renamed" => {
		1625	let path = format!("{}/{}", text("namespace"), text("to"));
		1626	for table in ["inbox_items", "inbox_watching"] {
		1627	statements.push(
		1628	db.prepare(format!("UPDATE {table} SET repo = ? WHERE repo_id = ?"))
		1629	.bind(&[path.as_str().into(), text("repoId").into()])?,
		1630	);
		1631	}
		1632	}
		1633	"repo.transferred" => {
		1634	let path = format!("{}/{}", text("to"), text("name"));
		1635	statements.push(
		1636	db.prepare("UPDATE inbox_items SET repo = ?, workspace = ? WHERE repo_id = ?")
		1637	.bind(&[path.as_str().into(), text("to").into(), text("repoId").into()])?,
		1638	);
		1639	statements.push(
		1640	db.prepare("UPDATE inbox_watching SET repo = ? WHERE repo_id = ?")
		1641	.bind(&[path.as_str().into(), text("repoId").into()])?,
		1642	);
		1643	}
		1644	"repo.purged" => {
		1645	for sql in [
		1646	"DELETE FROM inbox_activity WHERE item_id IN (SELECT id FROM inbox_items WHERE repo_id = ?)",
		1647	"DELETE FROM inbox_items WHERE repo_id = ?",
		1648	"DELETE FROM inbox_subscriptions WHERE repo_id = ?",
		1649	"DELETE FROM inbox_watching WHERE repo_id = ?",
		1650	] {
		1651	statements.push(db.prepare(sql).bind(&[text("repoId").into()])?);
		1652	}
		1653	}
		1654	"workspace.deleted" => {
		1655	statements.push(
		1656	db.prepare("DELETE FROM inbox_items WHERE workspace = ?")
		1657	.bind(&[text("slug").into()])?,
		1658	);
		1659	statements.push(
		1660	db.prepare("DELETE FROM inbox_watching WHERE repo LIKE ? || '/%'")
		1661	.bind(&[text("slug").into()])?,
		1662	);
		1663	}
Merge account deletion: soft delete for 30 days, staff restore and purge, ghost for what remains (identity 0037)1d ago		1664	// An account purged: its inbox, what it watched and its
		1665	// settings go with it (identity's account_deletion.rs).
		1666	"user.deleted" => {
		1667	let username = text("username");
		1668	if username.is_empty() {
		1669	continue;
		1670	}
		1671	for sql in [
		1672	"DELETE FROM inbox_activity WHERE username = ?",
		1673	"DELETE FROM inbox_items WHERE username = ?",
		1674	"DELETE FROM inbox_subscriptions WHERE username = ?",
		1675	"DELETE FROM inbox_watching WHERE username = ?",
		1676	"DELETE FROM inbox_settings WHERE username = ?",
		1677	] {
		1678	statements.push(db.prepare(sql).bind(&[username.as_str().into()])?);
		1679	}
		1680	}
Inbox: the events service tells people what needs them as events arrive2d ago		1681	_ => {}
		1682	}
		1683	}
		1684	if !statements.is_empty() {
		1685	db.batch(statements).await?;
		1686	}
		1687	Ok(())
		1688	}
		1689
		1690	/// Removes items done more than [`DONE_DAYS`] ago, and any not saved older
Inbox: threads, reasons, subscriptions and watching2d ago		1691	/// than [`MAX_DAYS`], with their history. Returns how many went.
Inbox: the events service tells people what needs them as events arrive2d ago		1692	pub async fn purge(db: &D1Database, now: u64) -> Result<u32> {
		1693	let done = crate::audit::keep_from(now, DONE_DAYS);
		1694	let oldest = crate::audit::keep_from(now, MAX_DAYS);
Inbox: threads, reasons, subscriptions and watching2d ago		1695	let statements: Vec<D1PreparedStatement> = vec![
		1696	db.prepare("DELETE FROM inbox_items WHERE saved = 0 AND done_at < ?")
		1697	.bind(&[done.into()])?,
		1698	db.prepare("DELETE FROM inbox_items WHERE saved = 0 AND COALESCE(updated_at, created_at) < ?")
		1699	.bind(&[oldest.into()])?,
		1700	db.prepare("DELETE FROM inbox_activity WHERE NOT EXISTS (SELECT 1 FROM inbox_items WHERE inbox_items.id = inbox_activity.item_id)"),
		1701	];
		1702	let results = db.batch(statements).await?;
Inbox: the events service tells people what needs them as events arrive2d ago		1703	let mut removed = 0;
Inbox: threads, reasons, subscriptions and watching2d ago		1704	for result in results.into_iter().take(2) {
Inbox: the events service tells people what needs them as events arrive2d ago		1705	removed += result.meta()?.and_then(|meta| meta.changes).unwrap_or(0) as u32;
		1706	}
		1707	Ok(removed)
		1708	}
		1709
		1710	#[cfg(test)]
		1711	mod tests {
		1712	use super::*;
Inbox: threads, reasons, subscriptions and watching2d ago		1713	use crate::subscriptions::{State, Subscription, Watcher};
Inbox: the events service tells people what needs them as events arrive2d ago		1714	use serde_json::json;
		1715
		1716	fn event(kind: &str, actor: Option<&str>, data: serde_json::Value) -> Event {
		1717	Event {
		1718	id: "evt_1".into(),
		1719	kind: kind.into(),
		1720	source: "work".into(),
		1721	time: "2026-10-07T12:00:00.000Z".into(),
		1722	repo_id: Some("rep_1".into()),
		1723	actor: actor.map(str::to_owned),
		1724	data,
		1725	}
		1726	}
		1727
		1728	fn person(id: &str, username: &str) -> Principal {
		1729	Principal {
		1730	id: id.into(),
		1731	username: username.into(),
		1732	}
		1733	}
		1734
		1735	fn actor(id: &str, username: &str) -> Actor {
		1736	Actor {
		1737	id: Some(id.into()),
		1738	username: Some(username.into()),
		1739	}
		1740	}
		1741
		1742	/// A pull request ana opened, assigned to bo, for an issue cy filed and dee is assigned.
		1743	fn pull() -> InboxSubject {
		1744	InboxSubject {
		1745	kind: Some(SubjectKind::Pull),
		1746	title: "Add the inbox".into(),
		1747	author: person("usr_ana", "ana"),
		1748	assignees: vec!["bo".into()],
		1749	issue: Some(Box::new(InboxSubject {
		1750	kind: Some(SubjectKind::Issue),
		1751	title: "An inbox".into(),
		1752	author: person("usr_cy", "cy"),
		1753	assignees: vec!["dee".into()],
		1754	..InboxSubject::default()
		1755	})),
		1756	..InboxSubject::default()
		1757	}
		1758	}
		1759
		1760	/// A change g1t made for ana.
		1761	fn g1t_pull() -> InboxSubject {
		1762	InboxSubject {
		1763	author: person(AGENT_ID, "g1t"),
		1764	requested_by: Some(person("usr_ana", "ana")),
		1765	..pull()
		1766	}
		1767	}
		1768
Inbox: threads, reasons, subscriptions and watching2d ago		1769	fn nobody() -> Audience {
		1770	Audience::default()
		1771	}
		1772
		1773	fn told(notices: &[Notice]) -> Vec<(&str, Reason, Severity)> {
Inbox: the events service tells people what needs them as events arrive2d ago		1774	notices
		1775	.iter()
		1776	.map(|notice| (notice.username.as_str(), notice.reason, notice.severity))
		1777	.collect()
		1778	}
		1779
		1780	fn comment(author: Principal, body: &str, mentions: &[&str]) -> InboxSubject {
		1781	InboxSubject {
		1782	comment: Some(InboxComment {
		1783	author,
		1784	excerpt: body.into(),
		1785	mentions: mentions.iter().map(|name| (*name).to_owned()).collect(),
		1786	..InboxComment::default()
		1787	}),
		1788	..pull()
		1789	}
		1790	}
		1791
Inbox: threads, reasons, subscriptions and watching2d ago		1792	fn subscribed(rows: &[(&str, State, Option<Reason>)]) -> Audience {
		1793	Audience {
		1794	subscriptions: rows
		1795	.iter()
		1796	.map(|(name, state, reason)| Subscription {
		1797	username: (*name).into(),
		1798	state: *state,
		1799	reason: *reason,
		1800	})
		1801	.collect(),
		1802	watchers: Vec::new(),
		1803	}
		1804	}
		1805
		1806	fn watched(rows: &[(&str, WatchLevel, &[&str])]) -> Audience {
		1807	Audience {
		1808	subscriptions: Vec::new(),
		1809	watchers: rows
		1810	.iter()
		1811	.map(|(name, level, events)| Watcher {
		1812	username: (*name).into(),
		1813	level: *level,
		1814	events: events.iter().map(|kind| (*kind).to_owned()).collect(),
		1815	})
		1816	.collect(),
		1817	}
		1818	}
		1819
Inbox: the events service tells people what needs them as events arrive2d ago		1820	#[test]
		1821	fn only_events_that_tell_someone_are_read() {
		1822	let asked = |kind: &str, data| wants(&event(kind, None, data));
		1823	assert_eq!(
		1824	asked("checks.completed", json!({ "repoId": "rep_1", "number": 4, "status": "failed" })),
		1825	Some(Wanted { repo_id: "rep_1".into(), number: Some(4), comment_id: None })
		1826	);
		1827	assert_eq!(asked("checks.completed", json!({ "repoId": "rep_1", "number": 4, "status": "passed" })), None);
		1828	assert_eq!(asked("review.completed", json!({ "repoId": "rep_1", "number": 4 })), None);
		1829	assert_eq!(asked("workflow.completed", json!({ "repoId": "rep_1", "conclusion": "success" })), None);
		1830	assert_eq!(
		1831	asked("workflow.completed", json!({ "repoId": "rep_1", "conclusion": "failure" })),
		1832	Some(Wanted { repo_id: "rep_1".into(), number: None, comment_id: None })
		1833	);
		1834	assert_eq!(
		1835	asked("comment.created", json!({ "repoId": "rep_1", "number": 2, "commentId": "cmt_1" })).map(|w| w.comment_id),
		1836	Some(Some("cmt_1".into()))
		1837	);
		1838	assert_eq!(asked("git.push", json!({ "repoId": "rep_1" })), None);
Inbox: threads, reasons, subscriptions and watching2d ago		1839	for kind in ["issue.opened", "pull.review_requested", "pull.stalled", "issue.assigned", "pull.closed", "issue.reopened"] {
		1840	assert!(asked(kind, json!({ "repoId": "rep_1", "number": 1 })).is_some(), "{kind}");
		1841	}
		1842	assert_eq!(asked("deployment.failed", json!({ "repoId": "rep_1" })).map(|w| w.number), Some(None));
Inbox: the events service tells people what needs them as events arrive2d ago		1843	}
		1844
		1845	#[test]
Inbox: threads, reasons, subscriptions and watching2d ago		1846	fn a_waiting_or_stopped_agent_needs_the_pull_requests_and_the_issues_people_first() {
Inbox: the events service tells people what needs them as events arrive2d ago		1847	let asked = event("agent.asked", Some("usr_agent"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching2d ago		1848	let notices_ = notices(&asked, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
Inbox: the events service tells people what needs them as events arrive2d ago		1849	assert_eq!(
Inbox: threads, reasons, subscriptions and watching2d ago		1850	told(&notices_),
Inbox: the events service tells people what needs them as events arrive2d ago		1851	vec![
Inbox: threads, reasons, subscriptions and watching2d ago		1852	("ana", Reason::Agent, Severity::Warning),
		1853	("cy", Reason::Agent, Severity::Warning),
		1854	("dee", Reason::Agent, Severity::Warning),
Inbox: the events service tells people what needs them as events arrive2d ago		1855	]
		1856	);
Inbox: threads, reasons, subscriptions and watching2d ago		1857	assert_eq!(notices_[0].title, "An agent is waiting on acme/rocket#7");
		1858	assert_eq!(notices_[0].body, "Add the inbox");
		1859	// Stopping says why; even someone who unsubscribed hears of it.
		1860	let stalled = event("pull.stalled", None, json!({ "number": 7, "detail": "Its checks could not be run." }));
		1861	let audience = subscribed(&[("ana", State::Unsubscribed, None)]);
		1862	let notices_ = notices(&stalled, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &audience);
		1863	assert_eq!(notices_[0].username, "ana");
		1864	assert_eq!(notices_[0].title, "g1t stopped on acme/rocket#7 and needs you");
		1865	assert_eq!(notices_[0].body, "Its checks could not be run.");
		1866	// Ignoring the thread silences even that.
		1867	let audience = subscribed(&[("ana", State::Ignored, None)]);
		1868	let notices_ = notices(&stalled, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &audience);
		1869	assert!(!notices_.iter().any(|notice| notice.username == "ana"));
		1870	}
		1871
		1872	#[test]
		1873	fn whatever_an_agent_waits_on_closes_when_it_goes_on() {
		1874	for kind in RESUMES {
		1875	assert_eq!(resolves(&event(kind, None, json!({ "repoId": "rep_1", "number": 7 }))), Some("rep_1#7".into()));
		1876	}
		1877	assert_eq!(resolves(&event("comment.created", None, json!({ "repoId": "rep_1", "number": 7 }))), None);
Inbox: the events service tells people what needs them as events arrive2d ago		1878	}
		1879
		1880	#[test]
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		1881	fn a_deployments_reviewers_are_told() {
		1882	let asked = event(
		1883	"deployment.review_requested",
		1884	Some("usr_ana"),
		1885	json!({
		1886	"repoId": "rep_1", "runId": "run_7", "environment": "production", "workflow": "Deploy",
		1887	"title": "Ship it", "notify": ["cy", "ana"], "link": "/acme/rocket/actions/runs/run_7"
		1888	}),
		1889	);
		1890	let wanted = wants(&asked).unwrap();
		1891	assert_eq!(wanted.number, None);
		1892	let thread = thread_of(&asked, &wanted, None);
		1893	assert_eq!(thread.key, "rep_1/review/run_7/production");
		1894	assert_eq!(thread.link.as_deref(), Some("/acme/rocket/actions/runs/run_7"));
		1895	let told = notices(&asked, "acme/rocket", &actor("usr_ana", "ana"), None, &nobody());
		1896	let names: Vec<&str> = told.iter().map(|notice| notice.username.as_str()).collect();
		1897	// Whoever started the run is told too, when they review it.
		1898	assert_eq!(names, ["cy", "ana"]);
		1899	assert!(told[0].title.contains("waiting for your review to deploy to production"));
		1900	}
		1901
		1902	#[test]
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		1903	fn teams_asked_to_review_tell_the_people_they_name() {
		1904	let requested = event(
		1905	"pull.review_requested",
		1906	Some("usr_ana"),
		1907	json!({ "number": 7, "reviewers": ["cy"], "teams": [
		1908	{ "team": "acme/backend", "notified": ["cy", "dee", "ana"], "assigned": ["cy"] }
		1909	] }),
		1910	);
		1911	let notices_ = notices(&requested, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1912	// cy was picked and is told as a reviewer; dee through the team;
		1913	// never whoever asked.
		1914	assert_eq!(
		1915	told(&notices_),
		1916	vec![("cy", Reason::ReviewRequested, Severity::Warning), ("dee", Reason::ReviewRequested, Severity::Warning)]
		1917	);
		1918	assert_eq!(notices_[0].title, "ana asked you to review acme/rocket#7");
		1919	assert_eq!(notices_[1].title, "ana asked @acme/backend to review acme/rocket#7");
		1920	assert_eq!(
		1921	subscribes(&requested, Some(&pull())),
		1922	vec![("cy".into(), Reason::ReviewRequested), ("dee".into(), Reason::ReviewRequested), ("ana".into(), Reason::ReviewRequested)]
		1923	);
		1924	// Asked by the CODEOWNERS file.
		1925	let owned = event(
		1926	"pull.review_requested",
		1927	None,
		1928	json!({ "number": 7, "reviewers": ["bo"], "codeOwners": true, "teams": [{ "team": "acme/docs", "notified": ["wren"], "assigned": [] }] }),
		1929	);
		1930	let notices_ = notices(&owned, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
		1931	assert_eq!(notices_[0].title, "acme/rocket#7 changes files you own");
		1932	assert_eq!(notices_[1].title, "acme/rocket#7 changes files @acme/docs owns");
		1933	}
		1934
		1935	#[test]
		1936	fn a_team_mention_tells_its_people_once_and_a_name_wins() {
		1937	let mut on = comment(person("usr_bo", "bo"), "cc @ana @acme/backend", &["ana"]);
		1938	if let Some(comment) = on.comment.as_mut() {
		1939	comment.team_mentions = vec![TeamMentioned {
		1940	team: "acme/backend".into(),
		1941	members: vec!["ana".into(), "cy".into(), "bo".into()],
		1942	}];
		1943	}
		1944	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		1945	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody());
		1946	let mentioned: Vec<(&str, Reason)> = notices_.iter().map(|n| (n.username.as_str(), n.reason)).filter(|(_, r)| matches!(r, Reason::Mention | Reason::TeamMention)).collect();
		1947	assert_eq!(mentioned, vec![("ana", Reason::Mention), ("cy", Reason::TeamMention)]);
		1948	assert_eq!(
		1949	notices_.iter().find(|n| n.username == "cy").unwrap().title,
		1950	"bo mentioned @acme/backend on acme/rocket#7"
		1951	);
		1952	let subscribed = subscribes(&created, Some(&on));
		1953	assert!(subscribed.contains(&("cy".into(), Reason::TeamMention)));
		1954	assert!(subscribed.contains(&("ana".into(), Reason::Mention)));
		1955	}
		1956
		1957	#[test]
		1958	fn a_description_tells_the_people_and_teams_it_mentions() {
		1959	let mut on = pull();
		1960	on.mentions = vec!["dee".into()];
		1961	on.team_mentions = vec![TeamMentioned {
		1962	team: "acme/web".into(),
		1963	members: vec!["eve".into()],
		1964	}];
		1965	let opened = event("pull.opened", Some("usr_ana"), json!({ "number": 7 }));
		1966	let notices_ = notices(&opened, "acme/rocket", &actor("usr_ana", "ana"), Some(&on), &nobody());
		1967	assert!(told(&notices_).contains(&("dee", Reason::Mention, Severity::Info)));
		1968	assert!(told(&notices_).contains(&("eve", Reason::TeamMention, Severity::Info)));
		1969	assert_eq!(
		1970	subscribes(&opened, Some(&on)),
		1971	vec![("dee".into(), Reason::Mention), ("eve".into(), Reason::TeamMention)]
		1972	);
		1973	}
		1974
		1975	#[test]
Inbox: threads, reasons, subscriptions and watching2d ago		1976	fn reviewers_and_assignees_asked_are_told_never_whoever_asked() {
		1977	let requested = event("pull.review_requested", Some("usr_ana"), json!({ "number": 7, "reviewers": ["bo", "g1t", "ana"] }));
		1978	let notices_ = notices(&requested, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1979	assert_eq!(told(&notices_), vec![("bo", Reason::ReviewRequested, Severity::Warning)]);
		1980	assert_eq!(notices_[0].title, "ana asked you to review acme/rocket#7");
		1981	let assigned = event("issue.assigned", Some("usr_ana"), json!({ "number": 3, "added": ["ana", "eve"] }));
		1982	let notices_ = notices(&assigned, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1983	assert_eq!(told(&notices_), vec![("eve", Reason::Assign, Severity::Info)]);
		1984	assert_eq!(notices_[0].title, "ana assigned you to acme/rocket#3");
		1985	// Both subscribe whoever they name, never g1t.
		1986	assert_eq!(subscribes(&requested, Some(&pull())), vec![("bo".into(), Reason::ReviewRequested), ("ana".into(), Reason::ReviewRequested)]);
		1987	assert_eq!(subscribes(&assigned, Some(&pull())), vec![("ana".into(), Reason::Assign), ("eve".into(), Reason::Assign)]);
		1988	}
		1989
		1990	#[test]
Inbox: the events service tells people what needs them as events arrive2d ago		1991	fn failures_go_to_whoever_answers_for_the_change() {
		1992	let failed = event("checks.completed", None, json!({ "number": 7, "status": "failed" }));
Inbox: threads, reasons, subscriptions and watching2d ago		1993	assert_eq!(
		1994	told(&notices(&failed, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		1995	vec![("ana", Reason::CiActivity, Severity::Error)]
		1996	);
Inbox: the events service tells people what needs them as events arrive2d ago		1997	// g1t's change is the person's who asked for it, never g1t's.
Inbox: threads, reasons, subscriptions and watching2d ago		1998	let notices_ = notices(&failed, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &nobody());
		1999	assert_eq!(told(&notices_), vec![("ana", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive2d ago		2000	let errored = event("checks.completed", None, json!({ "number": 7, "status": "errored" }));
Inbox: threads, reasons, subscriptions and watching2d ago		2001	assert_eq!(
		2002	notices(&errored, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())[0].title,
		2003	"Checks could not run on acme/rocket#7"
		2004	);
Inbox: the events service tells people what needs them as events arrive2d ago		2005	}
		2006
		2007	#[test]
		2008	fn a_workflow_that_fails_tells_its_pull_requests_owner_even_if_they_pushed() {
		2009	let failed = event("workflow.completed", Some("usr_ana"), json!({ "pull": 7, "workflow": "CI", "conclusion": "failure" }));
Inbox: threads, reasons, subscriptions and watching2d ago		2010	let notices_ = notices(&failed, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		2011	assert_eq!(told(&notices_), vec![("ana", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive2d ago		2012	assert_eq!(notices_[0].title, "CI failed on acme/rocket#7");
		2013	// On a branch: whoever pushed.
		2014	let pushed = event(
		2015	"workflow.completed",
		2016	Some("usr_bo"),
Inbox: threads, reasons, subscriptions and watching2d ago		2017	json!({ "workflow": "Deploy", "path": ".g1t/workflows/deploy.yml", "conclusion": "failure", "ref": "refs/heads/main", "number": 12, "sha": "abcdef0123", "runId": "run_9" }),
Inbox: the events service tells people what needs them as events arrive2d ago		2018	);
Inbox: threads, reasons, subscriptions and watching2d ago		2019	let notices_ = notices(&pushed, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody());
		2020	assert_eq!(told(&notices_), vec![("bo", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive2d ago		2021	assert_eq!(notices_[0].title, "Deploy failed on main in acme/rocket");
		2022	assert_eq!(notices_[0].body, "Run 12 at abcdef0");
		2023	// Nobody to tell when g1t pushed.
Inbox: threads, reasons, subscriptions and watching2d ago		2024	assert!(notices(&pushed, "acme/rocket", &actor("g1t", "g1t"), None, &nobody()).is_empty());
		2025	// Every failure of a workflow on a branch is one thread.
		2026	let wanted = wants(&pushed).unwrap();
		2027	let thread = thread_of(&pushed, &wanted, None);
		2028	assert_eq!(thread.key, "rep_1/run/.g1t/workflows/deploy.yml@main");
		2029	assert_eq!(thread.run_id.as_deref(), Some("run_9"));
		2030	}
		2031
		2032	#[test]
		2033	fn deployments_tell_whoever_answers_for_them_and_watchers() {
		2034	let failed = event(
		2035	"deployment.failed",
		2036	Some("usr_bo"),
		2037	json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "deploymentId": "dpl_1", "error": "The build failed.", "path": "/acme/rocket/deployments/dpl_1" }),
		2038	);
		2039	let audience = watched(&[("cy", WatchLevel::Custom, &["deployments"]), ("dee", WatchLevel::Custom, &["issues"]), ("eve", WatchLevel::All, &[])]);
		2040	let notices_ = notices(&failed, "acme/rocket", &actor("usr_bo", "bo"), None, &audience);
		2041	assert_eq!(
		2042	told(&notices_),
		2043	vec![
		2044	("bo", Reason::CiActivity, Severity::Error),
		2045	("cy", Reason::Subscribed, Severity::Error),
		2046	("eve", Reason::Subscribed, Severity::Error),
		2047	]
		2048	);
		2049	assert_eq!(notices_[0].title, "Production of rocket failed to deploy");
		2050	assert_eq!(notices_[0].body, "The build failed.");
		2051	let thread = thread_of(&failed, &wants(&failed).unwrap(), None);
		2052	assert_eq!(thread.key, "rep_1/deploy/prj_1/production");
		2053	assert_eq!(url(Some("acme/rocket"), thread.kind, None, None, thread.link.as_deref()), "/acme/rocket/deployments/dpl_1");
		2054	// A success is news to the owner only after a failure.
		2055	let live = event("deployment.succeeded", Some("usr_bo"), json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "commit": "abcdef0123" }));
		2056	assert!(notices(&live, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody()).is_empty());
		2057	let recovered = event("deployment.succeeded", Some("usr_bo"), json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "recovered": true }));
		2058	let notices_ = notices(&recovered, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody());
		2059	assert_eq!(told(&notices_), vec![("bo", Reason::CiActivity, Severity::Success)]);
		2060	assert_eq!(notices_[0].title, "Production of rocket is live again");
		2061	// A preview's is the pull request's owner's.
		2062	let preview = event("deployment.failed", None, json!({ "repoId": "rep_1", "projectId": "prj_1", "number": 7, "triggeredBy": "g1t" }));
		2063	assert_eq!(told(&notices(&preview, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())), vec![("ana", Reason::CiActivity, Severity::Error)]);
		2064	assert_eq!(thread_of(&preview, &wants(&preview).unwrap(), Some(&pull())).key, "rep_1/deploy/prj_1/7");
Inbox: the events service tells people what needs them as events arrive2d ago		2065	}
		2066
		2067	#[test]
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		2068	fn security_alerts_tell_the_pusher_the_owners_and_member_watchers() {
		2069	let blocked = event(
		2070	"secret_scanning_alert.created",
		2071	None,
		2072	json!({
		2073	"repoId": "rep_1", "alertId": "sec_1", "alertType": "secret_scanning", "severity": "critical",
		2074	"title": "An AWS access key in config/prod.env", "link": "/acme/rocket/security/secret-scanning/sec_1",
		2075	"state": "open", "pusher": "bo", "notify": ["ana"], "members": ["ana", "bo", "cy"]
		2076	}),
		2077	);
		2078	assert_eq!(wants(&blocked), Some(Wanted { repo_id: "rep_1".into(), number: None, comment_id: None }));
		2079	// cy watches for security alerts and is a member; eve watches
		2080	// everything but cannot see findings; dee watches issues only.
		2081	let audience = watched(&[
		2082	("cy", WatchLevel::Custom, &["security"]),
		2083	("dee", WatchLevel::Custom, &["issues"]),
		2084	("eve", WatchLevel::All, &[]),
		2085	]);
		2086	let notices_ = notices(&blocked, "acme/rocket", &Actor::default(), None, &audience);
		2087	assert_eq!(
		2088	told(&notices_),
		2089	vec![
		2090	("bo", Reason::SecurityAlert, Severity::Error),
		2091	("ana", Reason::SecurityAlert, Severity::Error),
		2092	("cy", Reason::SecurityAlert, Severity::Error),
		2093	]
		2094	);
		2095	assert_eq!(notices_[0].title, "A push to acme/rocket was blocked: it adds a secret");
		2096	assert_eq!(notices_[0].body, "An AWS access key in config/prod.env");
		2097	let thread = thread_of(&blocked, &wants(&blocked).unwrap(), None);
		2098	assert_eq!(thread.key, "rep_1/security/sec_1");
		2099	assert_eq!(url(Some("acme/rocket"), thread.kind, None, None, thread.link.as_deref()), "/acme/rocket/security/secret-scanning/sec_1");
		2100	// A bypass request goes to the reviewers named, never to watchers.
		2101	let requested = event(
		2102	"secret_scanning.bypass_requested",
		2103	Some("usr_bo"),
		2104	json!({ "repoId": "rep_1", "alertId": "sec_1", "requestId": "byp_1", "title": "An AWS access key in a.env", "notify": ["ana"], "link": "/acme/-/security/bypass-requests" }),
		2105	);
		2106	let notices_ = notices(&requested, "acme/rocket", &actor("usr_bo", "bo"), None, &audience);
		2107	assert_eq!(told(&notices_), vec![("ana", Reason::SecurityAlert, Severity::Warning)]);
		2108	assert_eq!(notices_[0].title, "bo asked to bypass push protection in acme/rocket");
		2109	// Fixes and dismissals are not news to the inbox.
		2110	assert_eq!(wants(&event("code_scanning_alert.fixed", None, json!({ "repoId": "rep_1" }))), None);
		2111	}
		2112
		2113	#[test]
Inbox: the events service tells people what needs them as events arrive2d ago		2114	fn nobody_hears_of_what_they_did_themselves() {
		2115	let merged = event("pull.merged", Some("usr_ana"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching2d ago		2116	let by_ana = notices(&merged, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		2117	// The assignee still hears; ana, who merged, does not.
		2118	assert_eq!(told(&by_ana), vec![("bo", Reason::StateChange, Severity::Success)]);
		2119	let by_bo = notices(&merged, "acme/rocket", &actor("usr_bo", "bo"), Some(&pull()), &nobody());
		2120	assert_eq!(told(&by_bo), vec![("ana", Reason::StateChange, Severity::Success)]);
Inbox: the events service tells people what needs them as events arrive2d ago		2121	assert_eq!(by_bo[0].title, "bo merged acme/rocket#7");
Inbox: threads, reasons, subscriptions and watching2d ago		2122	let by_queue = notices(&merged, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
Inbox: the events service tells people what needs them as events arrive2d ago		2123	assert_eq!(by_queue[0].title, "acme/rocket#7 was merged");
		2124	}
		2125
		2126	#[test]
Inbox: threads, reasons, subscriptions and watching2d ago		2127	fn closing_and_reopening_tells_everyone_subscribed_and_watchers() {
		2128	let closed = event("issue.closed", Some("usr_bo"), json!({ "number": 3, "reason": "completed" }));
		2129	let issue = InboxSubject {
		2130	kind: Some(SubjectKind::Issue),
		2131	title: "Crash".into(),
		2132	author: person("usr_cy", "cy"),
		2133	assignees: vec!["bo".into()],
		2134	..InboxSubject::default()
		2135	};
		2136	let mut audience = subscribed(&[("eve", State::Subscribed, Some(Reason::Comment)), ("fay", State::Unsubscribed, None)]);
		2137	audience.watchers = watched(&[("gus", WatchLevel::All, &[]), ("hal", WatchLevel::Custom, &["pulls"])]).watchers;
		2138	let notices_ = notices(&closed, "acme/rocket", &actor("usr_bo", "bo"), Some(&issue), &audience);
		2139	assert_eq!(
		2140	told(&notices_),
		2141	vec![
		2142	("cy", Reason::StateChange, Severity::Info),
		2143	("eve", Reason::StateChange, Severity::Info),
		2144	("gus", Reason::Subscribed, Severity::Info),
		2145	]
		2146	);
		2147	assert_eq!(notices_[0].title, "bo closed acme/rocket#3");
		2148	let by_pull = event("issue.closed", None, json!({ "number": 3, "resolvedBy": 9 }));
		2149	assert_eq!(notices(&by_pull, "acme/rocket", &Actor::default(), Some(&issue), &nobody())[0].title, "acme/rocket#3 was closed by #9");
		2150	let reopened = event("issue.reopened", Some("usr_cy"), json!({ "number": 3 }));
		2151	assert_eq!(told(&notices(&reopened, "acme/rocket", &actor("usr_cy", "cy"), Some(&issue), &nobody())), vec![("bo", Reason::StateChange, Severity::Info)]);
		2152	}
		2153
		2154	#[test]
		2155	fn opening_tells_who_it_names_and_watchers_of_its_kind() {
		2156	let opened = event("pull.opened", Some("usr_ana"), json!({ "number": 7 }));
		2157	let subject = InboxSubject { reviewers: vec!["cy".into(), "g1t".into()], ..pull() };
		2158	let audience = watched(&[("bo", WatchLevel::All, &[]), ("dee", WatchLevel::Custom, &["issues"]), ("eve", WatchLevel::Custom, &["pulls"]), ("fay", WatchLevel::Participating, &[])]);
		2159	let notices_ = notices(&opened, "acme/rocket", &actor("usr_ana", "ana"), Some(&subject), &audience);
		2160	assert_eq!(
		2161	told(&notices_),
		2162	vec![
		2163	("bo", Reason::Assign, Severity::Info),
		2164	("cy", Reason::ReviewRequested, Severity::Warning),
		2165	("eve", Reason::Subscribed, Severity::Info),
		2166	]
		2167	);
		2168	assert_eq!(notices_[2].title, "ana opened acme/rocket#7");
		2169	}
		2170
		2171	#[test]
		2172	fn ignoring_a_repository_silences_it_and_unsubscribing_keeps_only_what_is_asked() {
		2173	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		2174	let on = comment(person("usr_bo", "bo"), "@cy have a look", &["cy"]);
		2175	let audience = watched(&[("cy", WatchLevel::Ignore, &[]), ("ana", WatchLevel::All, &[])]);
		2176	assert!(notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience).iter().all(|notice| notice.username != "cy"));
		2177	let audience = subscribed(&[("cy", State::Unsubscribed, None), ("ana", State::Unsubscribed, None)]);
		2178	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience);
		2179	// cy was mentioned, which is asked of them; ana unsubscribed from the conversation.
		2180	assert_eq!(told(&notices_), vec![("cy", Reason::Mention, Severity::Info)]);
		2181	}
		2182
		2183	#[test]
Inbox: the events service tells people what needs them as events arrive2d ago		2184	fn g1t_finishing_or_reviewing_tells_the_person_it_worked_for() {
		2185	// The agent acts as the person it works for: still an outcome they hear of.
		2186	let ready = event("pull.ready", Some("usr_ana"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching2d ago		2187	let notices_ = notices(&ready, "acme/rocket", &actor("usr_ana", "ana"), Some(&g1t_pull()), &nobody());
		2188	assert_eq!(told(&notices_), vec![("ana", Reason::Author, Severity::Success)]);
Inbox: the events service tells people what needs them as events arrive2d ago		2189	assert_eq!(notices_[0].title, "g1t finished acme/rocket#7");
		2190	// A person's draft marked ready is not news to them.
Inbox: threads, reasons, subscriptions and watching2d ago		2191	assert!(notices(&ready, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody()).is_empty());
Inbox: the events service tells people what needs them as events arrive2d ago		2192
		2193	let approve = event("review.completed", None, json!({ "number": 7, "verdict": "approve" }));
Inbox: threads, reasons, subscriptions and watching2d ago		2194	assert_eq!(
		2195	told(&notices(&approve, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		2196	vec![("ana", Reason::Author, Severity::Success)]
		2197	);
Inbox: the events service tells people what needs them as events arrive2d ago		2198	let changes = event("review.completed", None, json!({ "number": 7, "verdict": "request_changes" }));
		2199	assert_eq!(
Inbox: threads, reasons, subscriptions and watching2d ago		2200	told(&notices(&changes, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		2201	vec![("ana", Reason::Author, Severity::Info)]
Inbox: the events service tells people what needs them as events arrive2d ago		2202	);
		2203	}
		2204
		2205	#[test]
Inbox: threads, reasons, subscriptions and watching2d ago		2206	fn comments_tell_those_mentioned_then_everyone_subscribed_never_the_writer() {
Inbox: the events service tells people what needs them as events arrive2d ago		2207	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		2208	let on = comment(person("usr_bo", "bo"), "@cy @bo have a look", &["cy", "bo", "g1t"]);
Inbox: threads, reasons, subscriptions and watching2d ago		2209	let audience = subscribed(&[("eve", State::Subscribed, Some(Reason::Comment)), ("fay", State::Subscribed, Some(Reason::Manual))]);
		2210	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience);
Inbox: the events service tells people what needs them as events arrive2d ago		2211	assert_eq!(
		2212	told(&notices_),
Inbox: threads, reasons, subscriptions and watching2d ago		2213	vec![
		2214	("cy", Reason::Mention, Severity::Info),
		2215	("ana", Reason::Author, Severity::Info),
		2216	("eve", Reason::Comment, Severity::Info),
		2217	("fay", Reason::Manual, Severity::Info),
		2218	]
Inbox: the events service tells people what needs them as events arrive2d ago		2219	);
		2220	assert_eq!(notices_[0].title, "bo mentioned you on acme/rocket#7");
Inbox: threads, reasons, subscriptions and watching2d ago		2221	assert_eq!(notices_[1].title, "bo commented on acme/rocket#7");
Inbox: the events service tells people what needs them as events arrive2d ago		2222	assert_eq!(notices_[0].body, "@cy @bo have a look");
		2223	// Mentioned and the owner: told once, as mentioned.
		2224	let on = comment(person("usr_bo", "bo"), "@ana", &["ana"]);
Inbox: threads, reasons, subscriptions and watching2d ago		2225	assert_eq!(
		2226	told(&notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody())),
		2227	vec![("ana", Reason::Mention, Severity::Info)]
		2228	);
		2229	// The owner's own comment tells the assignee, not the owner.
Inbox: the events service tells people what needs them as events arrive2d ago		2230	let on = comment(person("usr_ana", "ana"), "thanks", &[]);
Inbox: threads, reasons, subscriptions and watching2d ago		2231	assert_eq!(
		2232	told(&notices(&created, "acme/rocket", &actor("usr_ana", "ana"), Some(&on), &nobody())),
		2233	vec![("bo", Reason::Assign, Severity::Info)]
		2234	);
Inbox: the events service tells people what needs them as events arrive2d ago		2235	// Something that happened, not something written, tells nobody.
		2236	let mut on = comment(person("usr_bo", "bo"), "assigned cy", &[]);
		2237	on.comment.as_mut().unwrap().event = true;
Inbox: threads, reasons, subscriptions and watching2d ago		2238	assert!(notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody()).is_empty());
Inbox: the events service tells people what needs them as events arrive2d ago		2239	// An approval is good news.
Inbox: threads, reasons, subscriptions and watching2d ago		2240	let mut on = comment(person("usr_cy", "cy"), "", &[]);
Inbox: the events service tells people what needs them as events arrive2d ago		2241	on.comment.as_mut().unwrap().verdict = Some("approve".into());
Inbox: threads, reasons, subscriptions and watching2d ago		2242	let notices_ = notices(&created, "acme/rocket", &actor("usr_cy", "cy"), Some(&on), &nobody());
		2243	assert_eq!(told(&notices_)[0], ("ana", Reason::Author, Severity::Success));
Inbox: the events service tells people what needs them as events arrive2d ago		2244	assert_eq!(notices_[0].body, "Add the inbox");
Inbox: threads, reasons, subscriptions and watching2d ago		2245	// Writing and being mentioned subscribe, never g1t.
		2246	let on = comment(person("usr_bo", "bo"), "@cy", &["cy"]);
		2247	assert_eq!(subscribes(&created, Some(&on)), vec![("bo".into(), Reason::Comment), ("cy".into(), Reason::Mention)]);
		2248	let on = comment(person(AGENT_ID, "g1t"), "done", &[]);
		2249	assert!(subscribes(&created, Some(&on)).is_empty());
		2250	}
		2251
		2252	#[test]
		2253	fn issues_and_pull_requests_are_one_thread_each() {
		2254	let created = event("comment.created", Some("usr_bo"), json!({ "repoId": "rep_1", "number": 7, "commentId": "cmt_1" }));
		2255	let wanted = wants(&created).unwrap();
		2256	let thread = thread_of(&created, &wanted, Some(&pull()));
		2257	assert_eq!(thread.key, "rep_1#7");
		2258	assert_eq!(thread.kind, Some(SubjectKind::Pull));
		2259	let merged = event("pull.merged", None, json!({ "repoId": "rep_1", "number": 7 }));
		2260	assert_eq!(thread_of(&merged, &wants(&merged).unwrap(), Some(&pull())).key, thread.key);
Inbox: the events service tells people what needs them as events arrive2d ago		2261	}
		2262
		2263	#[test]
		2264	fn items_link_to_what_they_are_about() {
Inbox: threads, reasons, subscriptions and watching2d ago		2265	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Pull), Some(7), None, None), "/acme/rocket/pull/7");
		2266	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Issue), Some(3), None, None), "/acme/rocket/issues/3");
		2267	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Run), None, Some("run_1"), None), "/acme/rocket/actions/runs/run_1");
		2268	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Deploy), None, None, Some("/acme/site/deployments/dpl_1")), "/acme/site/deployments/dpl_1");
		2269	assert_eq!(url(Some("acme/rocket"), None, None, None, None), "/acme/rocket");
		2270	assert_eq!(url(None, None, None, None, None), "/inbox");
Inbox: the events service tells people what needs them as events arrive2d ago		2271	}
		2272
		2273	#[test]
		2274	fn long_titles_are_cut_to_a_line() {
		2275	let long = "x".repeat(400);
		2276	assert_eq!(clip(&long, MAX_TITLE).chars().count(), MAX_TITLE);
		2277	assert_eq!(clip(" short ", MAX_TITLE), "short");
		2278	}
		2279
		2280	#[test]
		2281	fn marks_change_only_what_they_say() {
		2282	assert_eq!(mark_change(InboxMark::Read), "read_at = COALESCE(read_at, ?1)");
		2283	assert!(mark_change(InboxMark::Done).contains("done_at = ?1"));
Inbox: threads, reasons, subscriptions and watching2d ago		2284	assert_eq!(mark_change(InboxMark::Unsnooze), "snoozed_until = NULL");
		2285	assert!(ranked(&ListInboxArgs::default()));
		2286	assert!(!ranked(&ListInboxArgs { reason: Some(Reason::Mention), ..ListInboxArgs::default() }));
		2287	assert!(!ranked(&ListInboxArgs { participating: true, ..ListInboxArgs::default() }));
		2288	}
		2289
		2290	#[test]
		2291	fn filters_bind_in_order_after_what_is_bound() {
		2292	let a = ListInboxArgs {
		2293	reason: Some(Reason::Mention),
		2294	repo_id: Some("rep_1".into()),
		2295	participating: true,
		2296	unread: true,
		2297	..ListInboxArgs::default()
		2298	};
		2299	// Two values come first: the username and now.
		2300	let (conditions, values) = filters(&a, 2);
		2301	assert_eq!(
		2302	conditions,
		2303	vec!["reason = ?3", "repo_id = ?4", "reason NOT IN ('manual', 'subscribed')", "read_at IS NULL"]
		2304	);
		2305	assert_eq!(values, vec!["mention", "rep_1"]);
		2306	}
		2307
		2308	#[test]
		2309	fn the_bump_keeps_whatever_is_most_urgent_while_unread() {
		2310	assert!(BUMP.contains("WHERE NOT EXISTS (SELECT 1 FROM inbox_activity WHERE event_id = ?4 AND username = ?2)"));
		2311	assert!(BUMP.contains("ON CONFLICT (username, thread) DO UPDATE"));
		2312	assert!(BUMP.contains("activity = inbox_items.activity + 1"));
		2313	// Its numbered parameters run from 1 to 19.
		2314	for at in 1..=19 {
		2315	assert!(BUMP.contains(&format!("?{at}")), "?{at}");
		2316	}
		2317	assert!(!BUMP.contains("?20"));
Inbox: the events service tells people what needs them as events arrive2d ago		2318	}
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		2319
		2320	#[test]
		2321	fn token_approvals_tell_the_people_named_about_no_repository() {
		2322	let mut asked = event(
		2323	"token.approval_requested",
		2324	Some("usr_ana"),
		2325	json!({ "workspace": "acme", "tokenId": "tok_1", "notify": ["Bo", "cy", "bo", "g1t"], "title": "ana asks", "body": "ci: contents: write", "link": "/acme/-/settings/tokens" }),
		2326	);
		2327	asked.repo_id = None;
		2328	let (thread, told) = workspace_notices(&asked, None);
		2329	assert_eq!(thread, "workspace:acme/token/tok_1");
		2330	let mut names: Vec<&str> = told.iter().map(|notice| notice.username.as_str()).collect();
		2331	names.sort();
		2332	assert_eq!(names, ["bo", "cy"], "each once, lowercased, never g1t");
		2333	assert!(told.iter().all(|notice| notice.reason == Reason::ReviewRequested && notice.severity == Severity::Warning));
		2334	assert!(wants(&asked).is_none(), "about no repository");
		2335	let reviewed = event("token.approval_reviewed", None, json!({ "workspace": "acme", "tokenId": "tok_1", "notify": ["ana"], "title": "approved" }));
		2336	let (_, told) = workspace_notices(&reviewed, None);
		2337	assert_eq!(told[0].reason, Reason::Author);
		2338	assert!(WORKSPACE_EVENTS.contains(&"token.approval_reviewed"));
		2339	}
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)18h ago		2340
		2341	#[test]
		2342	fn a_workspace_invitation_asks_its_person_and_tells_whoever_sent_it_the_answer() {
		2343	let mut sent = event(
		2344	"workspace_invitation.created",
		2345	Some("usr_owner"),
		2346	json!({ "workspace": "flagon-io", "invitationId": "inv_1", "thread": "invitation:inv_1", "notify": ["daweazl"], "title": "@syntaqx invited you to join Flagon, Inc.", "link": "/invitations" }),
		2347	);
		2348	sent.repo_id = None;
		2349	let (thread, told) = workspace_notices(&sent, None);
		2350	assert_eq!(thread, "invitation:inv_1");
		2351	assert_eq!(told.len(), 1);
		2352	assert_eq!((told[0].username.as_str(), told[0].reason, told[0].severity), ("daweazl", Reason::ReviewRequested, Severity::Warning));
		2353	let accepted = event("workspace_invitation.accepted", None, json!({ "workspace": "flagon-io", "thread": "invitation:inv_1", "notify": ["syntaqx"] }));
		2354	let (thread, told) = workspace_notices(&accepted, None);
		2355	assert_eq!(thread, "invitation:inv_1");
		2356	assert_eq!((told[0].reason, told[0].severity), (Reason::Author, Severity::Success));
		2357	let declined = event("workspace_invitation.declined", None, json!({ "workspace": "flagon-io", "thread": "invitation:inv_1", "notify": ["syntaqx"] }));
		2358	assert_eq!(workspace_notices(&declined, None).1[0].severity, Severity::Info);
		2359	// Answered or revoked, the person's item is done; a revocation tells nobody.
		2360	for kind in ["workspace_invitation.accepted", "workspace_invitation.declined", "workspace_invitation.revoked"] {
		2361	assert!(INVITATION_ANSWERED.contains(&kind));
		2362	}
		2363	assert!(!WORKSPACE_EVENTS.contains(&"workspace_invitation.revoked"));
		2364	}
Inbox: the events service tells people what needs them as events arrive2d ago		2365	}

This file's history is long; its oldest lines are credited to the oldest commit read.