diff --git a/apps/loopover-ui/public/openapi.json b/apps/loopover-ui/public/openapi.json index 4a8bfd6ef3..d481ba8a87 100644 --- a/apps/loopover-ui/public/openapi.json +++ b/apps/loopover-ui/public/openapi.json @@ -14584,6 +14584,25 @@ "recommendation", "summary" ] + }, + "AmsNotificationsAccepted": { + "type": "object", + "properties": { + "login": { + "type": "string" + }, + "accepted": { + "type": "number" + }, + "enqueued": { + "type": "number" + } + }, + "required": [ + "login", + "accepted", + "enqueued" + ] } }, "parameters": {}, @@ -19004,6 +19023,108 @@ } ] } + }, + "/v1/contributors/{login}/ams-notifications": { + "post": { + "summary": "Enqueue AMS notification events for a contributor", + "parameters": [ + { + "schema": { + "type": "string" + }, + "required": true, + "name": "login", + "in": "path" + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "events": { + "type": "array", + "items": { + "type": "object", + "properties": { + "eventType": { + "type": "string", + "enum": [ + "ams_attempt_started", + "ams_attempt_failed", + "ams_governor_paused", + "ams_pr_outcome" + ] + }, + "repoFullName": { + "type": "string" + }, + "pullNumber": { + "type": "integer", + "minimum": 0 + }, + "dedupKey": { + "type": "string" + }, + "deeplink": { + "type": "string" + }, + "actorLogin": { + "type": "string" + }, + "detectedAt": { + "type": "string" + } + }, + "required": [ + "eventType", + "repoFullName", + "pullNumber", + "dedupKey", + "deeplink", + "actorLogin", + "detectedAt" + ] + }, + "minItems": 1, + "maxItems": 20 + } + }, + "required": [ + "events" + ] + } + } + } + }, + "responses": { + "200": { + "description": "Accepts AMS-relevant notification events (attempt start/fail, governor pause, PR outcome) and evaluates them through the existing notify-evaluate → notify-deliver path (#7657).", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AmsNotificationsAccepted" + } + } + } + }, + "400": { + "description": "Invalid AMS notification body" + }, + "403": { + "description": "Forbidden when login does not match the authenticated session" + } + }, + "security": [ + { + "LoopOverBearer": [] + }, + { + "LoopOverSessionCookie": [] + } + ] + } } }, "servers": [ diff --git a/packages/loopover-miner/lib/ams-notifications.d.ts b/packages/loopover-miner/lib/ams-notifications.d.ts new file mode 100644 index 0000000000..d11a79add3 --- /dev/null +++ b/packages/loopover-miner/lib/ams-notifications.d.ts @@ -0,0 +1,65 @@ +export type AmsNotificationEventPayload = { + eventType: "ams_attempt_started" | "ams_attempt_failed" | "ams_governor_paused" | "ams_pr_outcome"; + recipientLogin: string; + repoFullName: string; + pullNumber: number; + dedupKey: string; + deeplink: string; + actorLogin: string; + detectedAt: string; +}; +export type AmsNotificationPublishResult = { + sent: number; + error?: string; +}; +export type AmsNotificationFetch = (url: string, init?: { + method?: string; + headers?: Record; + body?: string; + signal?: AbortSignal; +}) => Promise; +export type PublishAmsNotificationEventsOptions = { + env?: Record; + fetchFn?: AmsNotificationFetch; + timeoutMs?: number; + /** Test/self-host inject: mirrors job-dispatch evaluate → notify-deliver without HTTP. */ + dispatch?: (events: AmsNotificationEventPayload[]) => Promise; +}; +export declare const DEFAULT_AMS_NOTIFICATION_TIMEOUT_MS = 10000; +export declare function buildAmsAttemptStartedPayload(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + detectedAt?: string; +}): AmsNotificationEventPayload; +export declare function buildAmsAttemptFailedPayload(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + reason?: string | null; + detectedAt?: string; +}): AmsNotificationEventPayload; +export declare function buildAmsGovernorPausedPayload(input: { + recipientLogin: string; + reason?: string | null; + pausedAt?: string; + detectedAt?: string; +}): AmsNotificationEventPayload; +export declare function buildAmsPrOutcomePayload(input: { + recipientLogin: string; + repoFullName: string; + pullNumber: number; + decision: "merged" | "closed"; + closedAt?: string | null; + detectedAt?: string; +}): AmsNotificationEventPayload; +/** + * Publish AMS notification events through the hosted evaluate → notify-deliver path. Prefer an injected + * `dispatch` (tests / in-process self-host). Otherwise POST to `/v1/contributors/:login/ams-notifications` + * when a loopover-mcp session is on disk. Never throws. + */ +export declare function publishAmsNotificationEvents(events: AmsNotificationEventPayload[], options?: PublishAmsNotificationEventsOptions): Promise; +/** Fire-and-forget wrapper for sync call sites (never awaits into the caller's critical path). */ +export declare function scheduleAmsNotificationEvents(events: AmsNotificationEventPayload[], options?: PublishAmsNotificationEventsOptions): void; diff --git a/packages/loopover-miner/lib/ams-notifications.js b/packages/loopover-miner/lib/ams-notifications.js new file mode 100644 index 0000000000..6db68594d0 --- /dev/null +++ b/packages/loopover-miner/lib/ams-notifications.js @@ -0,0 +1,146 @@ +// AMS → hosted badge notifications (#7657). Builds DetectedNotificationEvent-shaped AMS kinds and POSTs them +// to the contributor ams-notifications ingest, which evaluates through evaluateNotificationEvent → +// notify-deliver (same handoff as src/queue/job-dispatch.ts). Fail-soft: a missing session or network blip +// never breaks the miner's real work. No parallel local notification store. +import { resolveLoopoverBackendSession } from "./github-token-resolution.js"; +export const DEFAULT_AMS_NOTIFICATION_TIMEOUT_MS = 10_000; +function normalizeLogin(login) { + return login.trim().toLowerCase(); +} +function nowIso() { + return new Date().toISOString(); +} +function githubIssueDeeplink(repoFullName, issueNumber) { + return `https://github.com/${repoFullName}/issues/${issueNumber}`; +} +function githubPullDeeplink(repoFullName, pullNumber) { + return `https://github.com/${repoFullName}/pull/${pullNumber}`; +} +export function buildAmsAttemptStartedPayload(input) { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + return { + eventType: "ams_attempt_started", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_started:${input.repoFullName}#${input.issueNumber}:${input.attemptId}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} +export function buildAmsAttemptFailedPayload(input) { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_attempt_failed", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_failed:${input.repoFullName}#${input.issueNumber}:${input.attemptId}${reasonKey}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} +export function buildAmsGovernorPausedPayload(input) { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const pausedAt = input.pausedAt ?? detectedAt; + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_governor_paused", + recipientLogin, + repoFullName: "ams/governor", + pullNumber: 0, + dedupKey: `ams_governor_paused:${recipientLogin}:${pausedAt}${reasonKey}`, + deeplink: "https://github.com/JSONbored/loopover", + actorLogin: recipientLogin, + detectedAt, + }; +} +export function buildAmsPrOutcomePayload(input) { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const closedAt = input.closedAt?.trim() || detectedAt; + return { + eventType: "ams_pr_outcome", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.pullNumber, + dedupKey: `ams_pr_outcome:${input.repoFullName}#${input.pullNumber}:${input.decision}:${closedAt}`, + deeplink: githubPullDeeplink(input.repoFullName, input.pullNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} +/** + * Publish AMS notification events through the hosted evaluate → notify-deliver path. Prefer an injected + * `dispatch` (tests / in-process self-host). Otherwise POST to `/v1/contributors/:login/ams-notifications` + * when a loopover-mcp session is on disk. Never throws. + */ +export async function publishAmsNotificationEvents(events, options = {}) { + if (!Array.isArray(events) || events.length === 0) + return { sent: 0 }; + if (options.dispatch) { + try { + await options.dispatch(events); + return { sent: events.length }; + } + catch (error) { + return { sent: 0, error: error instanceof Error ? error.message.slice(0, 160) : "dispatch_failed" }; + } + } + const env = options.env ?? process.env; + const session = resolveLoopoverBackendSession(env); + if (!session) + return { sent: 0, error: "no_session" }; + const recipientLogin = normalizeLogin(events[0].recipientLogin); + if (!recipientLogin) + return { sent: 0, error: "missing_recipient" }; + if (events.some((event) => normalizeLogin(event.recipientLogin) !== recipientLogin)) { + return { sent: 0, error: "mixed_recipients" }; + } + const fetchFn = options.fetchFn ?? fetch; + const timeoutMs = options.timeoutMs ?? DEFAULT_AMS_NOTIFICATION_TIMEOUT_MS; + const url = `${session.apiUrl}/v1/contributors/${encodeURIComponent(recipientLogin)}/ams-notifications`; + const body = JSON.stringify({ + events: events.map(({ eventType, repoFullName, pullNumber, dedupKey, deeplink, actorLogin, detectedAt }) => ({ + eventType, + repoFullName, + pullNumber, + dedupKey, + deeplink, + actorLogin, + detectedAt, + })), + }); + try { + const response = await fetchFn(url, { + method: "POST", + headers: { + authorization: `Bearer ${session.sessionToken}`, + "content-type": "application/json", + accept: "application/json", + }, + body, + signal: AbortSignal.timeout(timeoutMs), + }); + if (!response.ok) { + return { sent: 0, error: `http_${response.status}` }; + } + return { sent: events.length }; + } + catch (error) { + return { sent: 0, error: error instanceof Error ? error.message.slice(0, 160) : "network_failed" }; + } +} +/** Fire-and-forget wrapper for sync call sites (never awaits into the caller's critical path). */ +export function scheduleAmsNotificationEvents(events, options = {}) { + void publishAmsNotificationEvents(events, options).catch(() => { + // publishAmsNotificationEvents is already fail-soft; this only guards a rejected promise from an inject. + }); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/loopover-miner/lib/ams-notifications.ts b/packages/loopover-miner/lib/ams-notifications.ts new file mode 100644 index 0000000000..df1d0d3c0b --- /dev/null +++ b/packages/loopover-miner/lib/ams-notifications.ts @@ -0,0 +1,217 @@ +// AMS → hosted badge notifications (#7657). Builds DetectedNotificationEvent-shaped AMS kinds and POSTs them +// to the contributor ams-notifications ingest, which evaluates through evaluateNotificationEvent → +// notify-deliver (same handoff as src/queue/job-dispatch.ts). Fail-soft: a missing session or network blip +// never breaks the miner's real work. No parallel local notification store. +// +// Keep dedupKey / deeplink layout in lockstep with src/notifications/ams-events.ts (hosted twin — miner +// cannot import src/). + +import { resolveLoopoverBackendSession } from "./github-token-resolution.js"; + +export type AmsNotificationEventPayload = { + eventType: "ams_attempt_started" | "ams_attempt_failed" | "ams_governor_paused" | "ams_pr_outcome"; + recipientLogin: string; + repoFullName: string; + pullNumber: number; + dedupKey: string; + deeplink: string; + actorLogin: string; + detectedAt: string; +}; + +export type AmsNotificationPublishResult = { sent: number; error?: string }; + +export type AmsNotificationFetch = ( + url: string, + init?: { method?: string; headers?: Record; body?: string; signal?: AbortSignal }, +) => Promise; + +export type PublishAmsNotificationEventsOptions = { + env?: Record; + fetchFn?: AmsNotificationFetch; + timeoutMs?: number; + /** Test/self-host inject: mirrors job-dispatch evaluate → notify-deliver without HTTP. */ + dispatch?: (events: AmsNotificationEventPayload[]) => Promise; +}; + +export const DEFAULT_AMS_NOTIFICATION_TIMEOUT_MS = 10_000; + +function normalizeLogin(login: string): string { + return login.trim().toLowerCase(); +} + +function nowIso(): string { + return new Date().toISOString(); +} + +function githubIssueDeeplink(repoFullName: string, issueNumber: number): string { + return `https://github.com/${repoFullName}/issues/${issueNumber}`; +} + +function githubPullDeeplink(repoFullName: string, pullNumber: number): string { + return `https://github.com/${repoFullName}/pull/${pullNumber}`; +} + +export function buildAmsAttemptStartedPayload(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + detectedAt?: string; +}): AmsNotificationEventPayload { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + return { + eventType: "ams_attempt_started", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_started:${input.repoFullName}#${input.issueNumber}:${input.attemptId}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +export function buildAmsAttemptFailedPayload(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + reason?: string | null; + detectedAt?: string; +}): AmsNotificationEventPayload { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_attempt_failed", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_failed:${input.repoFullName}#${input.issueNumber}:${input.attemptId}${reasonKey}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +export function buildAmsGovernorPausedPayload(input: { + recipientLogin: string; + reason?: string | null; + pausedAt?: string; + detectedAt?: string; +}): AmsNotificationEventPayload { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const pausedAt = input.pausedAt ?? detectedAt; + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_governor_paused", + recipientLogin, + repoFullName: "ams/governor", + pullNumber: 0, + dedupKey: `ams_governor_paused:${recipientLogin}:${pausedAt}${reasonKey}`, + deeplink: "https://github.com/JSONbored/loopover", + actorLogin: recipientLogin, + detectedAt, + }; +} + +export function buildAmsPrOutcomePayload(input: { + recipientLogin: string; + repoFullName: string; + pullNumber: number; + decision: "merged" | "closed"; + closedAt?: string | null; + detectedAt?: string; +}): AmsNotificationEventPayload { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const closedAt = input.closedAt?.trim() || detectedAt; + return { + eventType: "ams_pr_outcome", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.pullNumber, + // Same layout as src/notifications/ams-events.ts buildAmsPrOutcomeEvent. + dedupKey: `ams_pr_outcome:${input.decision}:${input.repoFullName}#${input.pullNumber}:${closedAt}`, + deeplink: githubPullDeeplink(input.repoFullName, input.pullNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +/** + * Publish AMS notification events through the hosted evaluate → notify-deliver path. Prefer an injected + * `dispatch` (tests / in-process self-host). Otherwise POST to `/v1/contributors/:login/ams-notifications` + * when a loopover-mcp session is on disk. Never throws. + */ +export async function publishAmsNotificationEvents( + events: AmsNotificationEventPayload[], + options: PublishAmsNotificationEventsOptions = {}, +): Promise { + if (!Array.isArray(events) || events.length === 0) return { sent: 0 }; + if (options.dispatch) { + try { + await options.dispatch(events); + return { sent: events.length }; + } catch (error) { + return { sent: 0, error: error instanceof Error ? error.message.slice(0, 160) : "dispatch_failed" }; + } + } + + const env = options.env ?? process.env; + const session = resolveLoopoverBackendSession(env as NodeJS.ProcessEnv); + if (!session) return { sent: 0, error: "no_session" }; + + const recipientLogin = normalizeLogin(events[0]!.recipientLogin); + if (!recipientLogin) return { sent: 0, error: "missing_recipient" }; + if (events.some((event) => normalizeLogin(event.recipientLogin) !== recipientLogin)) { + return { sent: 0, error: "mixed_recipients" }; + } + + const fetchFn = options.fetchFn ?? (fetch as AmsNotificationFetch); + const timeoutMs = options.timeoutMs ?? DEFAULT_AMS_NOTIFICATION_TIMEOUT_MS; + const url = `${session.apiUrl}/v1/contributors/${encodeURIComponent(recipientLogin)}/ams-notifications`; + const body = JSON.stringify({ + events: events.map(({ eventType, repoFullName, pullNumber, dedupKey, deeplink, actorLogin, detectedAt }) => ({ + eventType, + repoFullName, + pullNumber, + dedupKey, + deeplink, + actorLogin, + detectedAt, + })), + }); + + try { + const response = await fetchFn(url, { + method: "POST", + headers: { + authorization: `Bearer ${session.sessionToken}`, + "content-type": "application/json", + accept: "application/json", + }, + body, + signal: AbortSignal.timeout(timeoutMs), + }); + if (!response.ok) { + return { sent: 0, error: `http_${response.status}` }; + } + return { sent: events.length }; + } catch (error) { + return { sent: 0, error: error instanceof Error ? error.message.slice(0, 160) : "network_failed" }; + } +} + +/** Fire-and-forget wrapper for sync call sites (never awaits into the caller's critical path). */ +export function scheduleAmsNotificationEvents( + events: AmsNotificationEventPayload[], + options: PublishAmsNotificationEventsOptions = {}, +): void { + void publishAmsNotificationEvents(events, options).catch(() => { + // publishAmsNotificationEvents is already fail-soft; this only guards a rejected promise from an inject. + }); +} diff --git a/packages/loopover-miner/lib/attempt-cli.d.ts b/packages/loopover-miner/lib/attempt-cli.d.ts index da9eda8923..aaa447bd46 100644 --- a/packages/loopover-miner/lib/attempt-cli.d.ts +++ b/packages/loopover-miner/lib/attempt-cli.d.ts @@ -9,6 +9,7 @@ import type { resolveRejectionSignaled as ResolveRejectionSignaledFn } from "./r import type { cleanupAttemptWorktree as CleanupAttemptWorktreeFn, prepareAttemptWorktree as PrepareAttemptWorktreeFn } from "./attempt-worktree.js"; import type { SelfReviewContextFetch, fetchSelfReviewContext as FetchSelfReviewContextFn } from "./self-review-context.js"; import type { buildCodingTaskSpec as BuildCodingTaskSpecFn } from "./coding-task-spec.js"; +import { scheduleAmsNotificationEvents, type PublishAmsNotificationEventsOptions } from "./ams-notifications.js"; import type { resolveAmsPolicy as ResolveAmsPolicyFn } from "./ams-policy.js"; import type { checkMinerKillSwitch as CheckMinerKillSwitchFn } from "./governor-kill-switch.js"; import type { getAttemptHistory as GetAttemptHistoryFn } from "./portfolio-queue.js"; @@ -94,6 +95,8 @@ export type RunAttemptOptions = { /** Hosted soft-claim coordination at work-start/work-end, when the plane is enabled (#7168). Defaults to * discovery-index-client.js's own submitSoftClaim. */ submitSoftClaim?: typeof SubmitSoftClaimFn; + /** AMS badge notifications (#7657). Defaults to scheduleAmsNotificationEvents (session POST / inject). */ + scheduleAmsNotifications?: (events: Parameters[0], options?: PublishAmsNotificationEventsOptions) => void; /** Invoked with the real structured result at every return point, in addition to (never instead of) the * plain exit-code return -- the loop orchestrator's real hook into what actually happened. */ onResult?: (result: AttemptCliResult) => void; diff --git a/packages/loopover-miner/lib/attempt-cli.js b/packages/loopover-miner/lib/attempt-cli.js index 495a16a3d2..26675d63d8 100644 --- a/packages/loopover-miner/lib/attempt-cli.js +++ b/packages/loopover-miner/lib/attempt-cli.js @@ -32,6 +32,7 @@ import { cleanupAttemptWorktree, prepareAttemptWorktree } from "./attempt-worktr import { fetchSelfReviewContext } from "./self-review-context.js"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; import { resolveAmsPolicy } from "./ams-policy.js"; +import { buildAmsAttemptFailedPayload, buildAmsAttemptStartedPayload, scheduleAmsNotificationEvents, } from "./ams-notifications.js"; import { checkMinerKillSwitch, recordMinerKillSwitchTransition } from "./governor-kill-switch.js"; import { captureMinerError } from "./sentry.js"; import { buildAttemptGovernorContext, buildAttemptLoopInput } from "./attempt-input-builder.js"; @@ -505,6 +506,16 @@ export async function runAttempt(args, options = {}) { await submitClaim(claimRecord, { env }); } const runAttemptPipeline = options.runMinerAttempt ?? runMinerAttempt; + const scheduleAmsNotifications = options.scheduleAmsNotifications ?? scheduleAmsNotificationEvents; + // AMS badge notify (#7657): attempt start — fire-and-forget through the hosted evaluate → deliver path. + scheduleAmsNotifications([ + buildAmsAttemptStartedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + }), + ], { env: env }); let result; try { result = await runAttemptPipeline({ @@ -528,9 +539,29 @@ export async function runAttempt(args, options = {}) { // `undefined` and the finally block's `?? true` default (meant for the earlier blocked paths that never // ran anything in the worktree) deleted it -- inverting shouldRetainWorktree's documented policy. worktreeResult.attemptOk = false; + scheduleAmsNotifications([ + buildAmsAttemptFailedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + reason: "attempt_crashed", + }), + ], { env: env }); throw error; } worktreeResult.attemptOk = result.outcome === "submitted"; + if (result.outcome !== "submitted") { + scheduleAmsNotifications([ + buildAmsAttemptFailedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + reason: result.outcome, + }), + ], { env: env }); + } // Real claim-conflict resolution (#4848): only meaningful once a real PR exists, so this only ever runs // on a real "submitted" outcome. checkSubmissionFreshness (inside runMinerAttempt) already caught the // common pre-submission case; this closes the narrower TOCTOU window where two miners raced past that @@ -695,4 +726,4 @@ export async function runAttempt(args, options = {}) { governorLedger?.close(); } } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attempt-cli.js","sourceRoot":"","sources":["attempt-cli.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attempt-cli.js","sourceRoot":"","sources":["attempt-cli.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/loopover-miner/lib/attempt-cli.ts b/packages/loopover-miner/lib/attempt-cli.ts index 2367774f46..58751d181d 100644 --- a/packages/loopover-miner/lib/attempt-cli.ts +++ b/packages/loopover-miner/lib/attempt-cli.ts @@ -48,6 +48,12 @@ import type { SelfReviewContextFetch, fetchSelfReviewContext as FetchSelfReviewC import { buildCodingTaskSpec } from "./coding-task-spec.js"; import type { buildCodingTaskSpec as BuildCodingTaskSpecFn } from "./coding-task-spec.js"; import { resolveAmsPolicy } from "./ams-policy.js"; +import { + buildAmsAttemptFailedPayload, + buildAmsAttemptStartedPayload, + scheduleAmsNotificationEvents, + type PublishAmsNotificationEventsOptions, +} from "./ams-notifications.js"; import type { resolveAmsPolicy as ResolveAmsPolicyFn } from "./ams-policy.js"; import { checkMinerKillSwitch, recordMinerKillSwitchTransition } from "./governor-kill-switch.js"; import type { checkMinerKillSwitch as CheckMinerKillSwitchFn } from "./governor-kill-switch.js"; @@ -141,6 +147,11 @@ export type RunAttemptOptions = { /** Hosted soft-claim coordination at work-start/work-end, when the plane is enabled (#7168). Defaults to * discovery-index-client.js's own submitSoftClaim. */ submitSoftClaim?: typeof SubmitSoftClaimFn; + /** AMS badge notifications (#7657). Defaults to scheduleAmsNotificationEvents (session POST / inject). */ + scheduleAmsNotifications?: ( + events: Parameters[0], + options?: PublishAmsNotificationEventsOptions, + ) => void; /** Invoked with the real structured result at every return point, in addition to (never instead of) the * plain exit-code return -- the loop orchestrator's real hook into what actually happened. */ onResult?: (result: AttemptCliResult) => void; @@ -666,6 +677,19 @@ export async function runAttempt(args: string[], options: RunAttemptOptions = {} } const runAttemptPipeline = options.runMinerAttempt ?? runMinerAttempt; + const scheduleAmsNotifications = options.scheduleAmsNotifications ?? scheduleAmsNotificationEvents; + // AMS badge notify (#7657): attempt start — fire-and-forget through the hosted evaluate → deliver path. + scheduleAmsNotifications( + [ + buildAmsAttemptStartedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + }), + ], + { env: env as NodeJS.ProcessEnv }, + ); let result; try { result = await runAttemptPipeline( @@ -691,10 +715,36 @@ export async function runAttempt(args: string[], options: RunAttemptOptions = {} // `undefined` and the finally block's `?? true` default (meant for the earlier blocked paths that never // ran anything in the worktree) deleted it -- inverting shouldRetainWorktree's documented policy. worktreeResult.attemptOk = false; + scheduleAmsNotifications( + [ + buildAmsAttemptFailedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + reason: "attempt_crashed", + }), + ], + { env: env as NodeJS.ProcessEnv }, + ); throw error; } worktreeResult.attemptOk = result.outcome === "submitted"; + if (result.outcome !== "submitted") { + scheduleAmsNotifications( + [ + buildAmsAttemptFailedPayload({ + recipientLogin: parsed.minerLogin, + repoFullName: parsed.repoFullName, + issueNumber: parsed.issueNumber, + attemptId, + reason: result.outcome, + }), + ], + { env: env as NodeJS.ProcessEnv }, + ); + } // Real claim-conflict resolution (#4848): only meaningful once a real PR exists, so this only ever runs // on a real "submitted" outcome. checkSubmissionFreshness (inside runMinerAttempt) already caught the diff --git a/packages/loopover-miner/lib/governor-pause-cli.d.ts b/packages/loopover-miner/lib/governor-pause-cli.d.ts index 7677e385d4..a92a147248 100644 --- a/packages/loopover-miner/lib/governor-pause-cli.d.ts +++ b/packages/loopover-miner/lib/governor-pause-cli.d.ts @@ -1,4 +1,5 @@ import type { GovernorState } from "./governor-state.js"; +import { publishAmsNotificationEvents } from "./ams-notifications.js"; export type ParsedGovernorPauseArgs = { json: boolean; dryRun: boolean; @@ -19,6 +20,13 @@ export type ParsedGovernorNoArgsSubcommand = { }; export type GovernorPauseCliOptions = { openGovernorState?: () => GovernorState; + env?: Record; + /** Override AMS badge notify (#7657). Defaults to publishAmsNotificationEvents. */ + publishAmsNotifications?: typeof publishAmsNotificationEvents; + fetchSessionLogin?: (session: { + apiUrl: string; + sessionToken: string; + }) => Promise; }; export declare function parseGovernorPauseArgs(args: string[]): ParsedGovernorPauseArgs; export declare function parseGovernorResumeArgs(args: string[]): ParsedGovernorResumeArgs; diff --git a/packages/loopover-miner/lib/governor-pause-cli.js b/packages/loopover-miner/lib/governor-pause-cli.js index 698b749f48..389b018114 100644 --- a/packages/loopover-miner/lib/governor-pause-cli.js +++ b/packages/loopover-miner/lib/governor-pause-cli.js @@ -7,6 +7,8 @@ // same reasoning that table's other scalar fields (rate-limit buckets, cap usage) already rely on. import { argsWantJson, describeCliError, reportCliFailure } from "./cli-error.js"; import { openGovernorState } from "./governor-state.js"; +import { buildAmsGovernorPausedPayload, publishAmsNotificationEvents, } from "./ams-notifications.js"; +import { resolveLoopoverBackendSession } from "./github-token-resolution.js"; const GOVERNOR_PAUSE_USAGE = "Usage: loopover-miner governor pause [--reason ] [--dry-run] [--json]"; const GOVERNOR_RESUME_USAGE = "Usage: loopover-miner governor resume [--dry-run] [--json]"; const GOVERNOR_STATUS_USAGE = "Usage: loopover-miner governor status [--json]"; @@ -79,6 +81,44 @@ function renderPauseState(pauseState) { const reason = pauseState.reason ? ` (${pauseState.reason})` : ""; return `governor is PAUSED since ${pauseState.pausedAt}${reason}`; } +async function resolveSessionLogin(env) { + const session = resolveLoopoverBackendSession(env); + if (!session) + return null; + try { + const response = await fetch(`${session.apiUrl}/v1/auth/session`, { + headers: { authorization: `Bearer ${session.sessionToken}`, accept: "application/json" }, + signal: AbortSignal.timeout(10_000), + }); + if (!response.ok) + return null; + const payload = (await response.json().catch(() => null)); + return typeof payload?.login === "string" && payload.login.trim() ? payload.login.trim() : null; + } + catch { + return null; + } +} +async function notifyGovernorPaused(pauseState, options) { + const env = options.env ?? process.env; + // Injected fetchSessionLogin (tests) may resolve a login without a disk session; only require a real + // session when falling back to GET /v1/auth/session. + const processEnv = env; + const login = options.fetchSessionLogin + ? await options.fetchSessionLogin(resolveLoopoverBackendSession(processEnv) ?? { apiUrl: "https://api.loopover.ai", sessionToken: "" }) + : await resolveSessionLogin(processEnv); + if (!login) + return; + const publish = options.publishAmsNotifications ?? publishAmsNotificationEvents; + const publishOptions = { env }; + await publish([ + buildAmsGovernorPausedPayload({ + recipientLogin: login, + reason: pauseState.reason, + ...(pauseState.pausedAt ? { pausedAt: pauseState.pausedAt } : {}), + }), + ], publishOptions); +} export async function runGovernorPause(args, options = {}) { const parsed = parseGovernorPauseArgs(args); if ("error" in parsed) { @@ -96,16 +136,16 @@ export async function runGovernorPause(args, options = {}) { return 0; } try { - return await withGovernorState(options, (governorState) => { - const pauseState = governorState.savePauseState({ paused: true, reason: parsed.reason }); - if (parsed.json) { - console.log(JSON.stringify(pauseState)); - } - else { - console.log(renderPauseState(pauseState)); - } - return 0; - }); + const pauseState = await withGovernorState(options, (governorState) => governorState.savePauseState({ paused: true, reason: parsed.reason })); + // AMS badge notify (#7657): best-effort; a notify miss must not fail the pause itself. + await notifyGovernorPaused(pauseState, options).catch(() => undefined); + if (parsed.json) { + console.log(JSON.stringify(pauseState)); + } + else { + console.log(renderPauseState(pauseState)); + } + return 0; } catch (error) { return reportCliFailure(parsed.json, describeCliError(error)); @@ -163,4 +203,4 @@ export async function runGovernorStatus(args, options = {}) { return reportCliFailure(parsed.json, describeCliError(error)); } } -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"governor-pause-cli.js","sourceRoot":"","sources":["governor-pause-cli.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/loopover-miner/lib/governor-pause-cli.ts b/packages/loopover-miner/lib/governor-pause-cli.ts index 2f28fc6a14..a4b8d11610 100644 --- a/packages/loopover-miner/lib/governor-pause-cli.ts +++ b/packages/loopover-miner/lib/governor-pause-cli.ts @@ -9,6 +9,12 @@ import { argsWantJson, describeCliError, reportCliFailure } from "./cli-error.js"; import { openGovernorState } from "./governor-state.js"; import type { GovernorPauseState, GovernorState } from "./governor-state.js"; +import { + buildAmsGovernorPausedPayload, + publishAmsNotificationEvents, + type PublishAmsNotificationEventsOptions, +} from "./ams-notifications.js"; +import { resolveLoopoverBackendSession } from "./github-token-resolution.js"; const GOVERNOR_PAUSE_USAGE = "Usage: loopover-miner governor pause [--reason ] [--dry-run] [--json]"; const GOVERNOR_RESUME_USAGE = "Usage: loopover-miner governor resume [--dry-run] [--json]"; @@ -24,6 +30,10 @@ export type ParsedGovernorNoArgsSubcommand = { json: boolean } | { error: string export type GovernorPauseCliOptions = { openGovernorState?: () => GovernorState; + env?: Record; + /** Override AMS badge notify (#7657). Defaults to publishAmsNotificationEvents. */ + publishAmsNotifications?: typeof publishAmsNotificationEvents; + fetchSessionLogin?: (session: { apiUrl: string; sessionToken: string }) => Promise; }; export function parseGovernorPauseArgs(args: string[]): ParsedGovernorPauseArgs { @@ -101,6 +111,50 @@ function renderPauseState(pauseState: GovernorPauseState): string { return `governor is PAUSED since ${pauseState.pausedAt}${reason}`; } +async function resolveSessionLogin(env: NodeJS.ProcessEnv): Promise { + const session = resolveLoopoverBackendSession(env); + if (!session) return null; + try { + const response = await fetch(`${session.apiUrl}/v1/auth/session`, { + headers: { authorization: `Bearer ${session.sessionToken}`, accept: "application/json" }, + signal: AbortSignal.timeout(10_000), + }); + if (!response.ok) return null; + const payload = (await response.json().catch(() => null)) as { login?: unknown } | null; + return typeof payload?.login === "string" && payload.login.trim() ? payload.login.trim() : null; + } catch { + return null; + } +} + +async function notifyGovernorPaused( + pauseState: GovernorPauseState, + options: GovernorPauseCliOptions, +): Promise { + const env = options.env ?? process.env; + // Injected fetchSessionLogin (tests) may resolve a login without a disk session; only require a real + // session when falling back to GET /v1/auth/session. + const processEnv = env as NodeJS.ProcessEnv; + const login = options.fetchSessionLogin + ? await options.fetchSessionLogin( + resolveLoopoverBackendSession(processEnv) ?? { apiUrl: "https://api.loopover.ai", sessionToken: "" }, + ) + : await resolveSessionLogin(processEnv); + if (!login) return; + const publish = options.publishAmsNotifications ?? publishAmsNotificationEvents; + const publishOptions: PublishAmsNotificationEventsOptions = { env }; + await publish( + [ + buildAmsGovernorPausedPayload({ + recipientLogin: login, + reason: pauseState.reason, + ...(pauseState.pausedAt ? { pausedAt: pauseState.pausedAt } : {}), + }), + ], + publishOptions, + ); +} + export async function runGovernorPause(args: string[], options: GovernorPauseCliOptions = {}): Promise { const parsed = parseGovernorPauseArgs(args); if ("error" in parsed) { @@ -119,15 +173,17 @@ export async function runGovernorPause(args: string[], options: GovernorPauseCli } try { - return await withGovernorState(options, (governorState) => { - const pauseState = governorState.savePauseState({ paused: true, reason: parsed.reason }); - if (parsed.json) { - console.log(JSON.stringify(pauseState)); - } else { - console.log(renderPauseState(pauseState)); - } - return 0; - }); + const pauseState = await withGovernorState(options, (governorState) => + governorState.savePauseState({ paused: true, reason: parsed.reason }), + ); + // AMS badge notify (#7657): best-effort; a notify miss must not fail the pause itself. + await notifyGovernorPaused(pauseState, options).catch(() => undefined); + if (parsed.json) { + console.log(JSON.stringify(pauseState)); + } else { + console.log(renderPauseState(pauseState)); + } + return 0; } catch (error) { return reportCliFailure(parsed.json, describeCliError(error)); } diff --git a/packages/loopover-miner/lib/loop-cli.js b/packages/loopover-miner/lib/loop-cli.js index 2dc48b7156..0cafa5a34f 100644 --- a/packages/loopover-miner/lib/loop-cli.js +++ b/packages/loopover-miner/lib/loop-cli.js @@ -452,7 +452,7 @@ export async function runLoop(args, options = {}) { prNumber, decision: prDisposition.merged ? "merged" : "closed", closedAt: prDisposition.closedAt, - }, { eventLedger }); + }, { eventLedger, recipientLogin: parsed.minerLogin }); // Real per-repo reputation history (#5675): a resolved terminal outcome updates the decided/unfavorable // counts the Governor's self-reputation throttle reads on this repo's next attempt. `decided` always; // `unfavorable` only on a closed-without-merge (rejection-state-machine.js's isRejectedPr, matching @@ -529,4 +529,4 @@ export async function runLoop(args, options = {}) { runState.close(); } } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loop-cli.js","sourceRoot":"","sources":["loop-cli.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loop-cli.js","sourceRoot":"","sources":["loop-cli.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/loopover-miner/lib/loop-cli.ts b/packages/loopover-miner/lib/loop-cli.ts index 676362879a..7b8037047e 100644 --- a/packages/loopover-miner/lib/loop-cli.ts +++ b/packages/loopover-miner/lib/loop-cli.ts @@ -567,7 +567,7 @@ export async function runLoop(args: string[], options: RunLoopOptions = {}): Pro decision: prDisposition.merged ? "merged" : "closed", closedAt: prDisposition.closedAt, }, - { eventLedger }, + { eventLedger, recipientLogin: parsed.minerLogin }, ); // Real per-repo reputation history (#5675): a resolved terminal outcome updates the decided/unfavorable // counts the Governor's self-reputation throttle reads on this repo's next attempt. `decided` always; diff --git a/packages/loopover-miner/lib/pr-outcome.d.ts b/packages/loopover-miner/lib/pr-outcome.d.ts index 81e7d723bd..562d10dc14 100644 --- a/packages/loopover-miner/lib/pr-outcome.d.ts +++ b/packages/loopover-miner/lib/pr-outcome.d.ts @@ -1,4 +1,5 @@ import type { AppendEventInput, LedgerEntry } from "./event-ledger.js"; +import { scheduleAmsNotificationEvents, type PublishAmsNotificationEventsOptions } from "./ams-notifications.js"; /** Event-ledger vocabulary for a miner-local PR outcome. */ export declare const MINER_PR_OUTCOME_EVENT: "pr_outcome"; /** The terminal decisions a miner records for one of its own PRs. */ @@ -24,6 +25,10 @@ export type RecordPrOutcomeOptions = { eventLedger?: { appendEvent(event: AppendEventInput): LedgerEntry; }; + /** Recipient for AMS badge notify (#7657). When absent, notification is skipped (ledger write still happens). */ + recipientLogin?: string; + env?: Record; + scheduleAmsNotifications?: (events: Parameters[0], options?: PublishAmsNotificationEventsOptions) => void; }; export type PrOutcomeLedgerReader = { readEvents(filter?: { diff --git a/packages/loopover-miner/lib/pr-outcome.js b/packages/loopover-miner/lib/pr-outcome.js index a4ec93d12f..afa37df93e 100644 --- a/packages/loopover-miner/lib/pr-outcome.js +++ b/packages/loopover-miner/lib/pr-outcome.js @@ -9,6 +9,7 @@ // its own PRs (it may have no webhook relay at all): same concept name, different codebase layer, no shared code. // The distinct `MINER_PR_OUTCOME_EVENT` local constant keeps the two from being conflated. import { REJECTION_REASONS } from "./rejection-templates.js"; +import { buildAmsPrOutcomePayload, scheduleAmsNotificationEvents, } from "./ams-notifications.js"; /** Event-ledger vocabulary for a miner-local PR outcome. */ export const MINER_PR_OUTCOME_EVENT = "pr_outcome"; /** The terminal decisions a miner records for one of its own PRs. */ @@ -69,7 +70,22 @@ export function recordPrOutcomeSnapshot(input, options = {}) { }); if (!payload) return null; - return eventLedger.appendEvent({ type: MINER_PR_OUTCOME_EVENT, repoFullName, payload }); + const entry = eventLedger.appendEvent({ type: MINER_PR_OUTCOME_EVENT, repoFullName, payload }); + // AMS badge notify (#7657): fire-and-forget when a recipient login is known (loop-cli passes minerLogin). + const recipientLogin = typeof options.recipientLogin === "string" ? options.recipientLogin.trim() : ""; + if (recipientLogin) { + const schedule = options.scheduleAmsNotifications ?? scheduleAmsNotificationEvents; + schedule([ + buildAmsPrOutcomePayload({ + recipientLogin, + repoFullName, + pullNumber: payload.prNumber, + decision: payload.decision, + closedAt: payload.closedAt, + }), + ], { env: options.env ?? process.env }); + } + return entry; } /** * Reconstruct the latest outcome per repo/PR from the ledger's ascending append-only event stream (mirrors @@ -102,4 +118,4 @@ export function readPrOutcomes(eventLedger, filter = {}) { } return latest; } -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHItb3V0Y29tZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInByLW91dGNvbWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaUhBQWlIO0FBQ2pILDBHQUEwRztBQUMxRyxpSEFBaUg7QUFDakgsOEJBQThCO0FBQzlCLEVBQUU7QUFDRiw2R0FBNkc7QUFDN0csK0dBQStHO0FBQy9HLDhHQUE4RztBQUM5RyxrSEFBa0g7QUFDbEgsMkZBQTJGO0FBRTNGLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTdELE9BQU8sRUFDTCx3QkFBd0IsRUFDeEIsNkJBQTZCLEdBRTlCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMsNERBQTREO0FBQzVELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLFlBQXFCLENBQUM7QUFFNUQscUVBQXFFO0FBQ3JFLE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFVLENBQUMsQ0FBQztBQXFDdkYsTUFBTSxXQUFXLEdBQUcsSUFBSSxHQUFHLENBQVMsMEJBQTBCLENBQUMsQ0FBQztBQUNoRSxNQUFNLFNBQVMsR0FBRyxJQUFJLEdBQUcsQ0FBUyxpQkFBaUIsQ0FBQyxDQUFDO0FBRXJELFNBQVMsY0FBYyxDQUFDLEtBQWM7SUFDcEMsSUFBSSxLQUFLLEtBQUssU0FBUyxJQUFJLEtBQUssS0FBSyxJQUFJO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDdkQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDM0MsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzdCLE9BQU8sT0FBTyxJQUFJLElBQUksQ0FBQztBQUN6QixDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUseUJBQXlCLENBQUMsT0FBZ0I7SUFDeEQsSUFBSSxDQUFDLE9BQU8sSUFBSSxPQUFPLE9BQU8sS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUM7UUFBRSxPQUFPLElBQUksQ0FBQztJQUNuRixNQUFNLE1BQU0sR0FBRyxPQUFrQyxDQUFDO0lBQ2xELElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSyxNQUFNLENBQUMsUUFBbUIsSUFBSSxDQUFDO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDeEYsTUFBTSxRQUFRLEdBQUcsY0FBYyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNqRCxJQUFJLENBQUMsUUFBUSxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7UUFBRSxPQUFPLElBQUksQ0FBQztJQUN6RCxNQUFNLFNBQVMsR0FBRyxjQUFjLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hELE1BQU0sTUFBTSxHQUFHLFFBQVEsS0FBSyxRQUFRLElBQUksU0FBUyxLQUFLLElBQUksSUFBSSxTQUFTLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUMxRyxPQUFPO1FBQ0wsUUFBUSxFQUFFLE1BQU0sQ0FBQyxRQUFrQjtRQUNuQyxRQUFRLEVBQUUsUUFBa0M7UUFDNUMsUUFBUSxFQUFFLGNBQWMsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDO1FBQ3pDLE1BQU07S0FDUCxDQUFDO0FBQ0osQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxLQUFxQixFQUFFLFVBQWtDLEVBQUU7SUFDakcsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUN4QyxJQUFJLENBQUMsV0FBVyxJQUFJLE9BQU8sV0FBVyxDQUFDLFdBQVcsS0FBSyxVQUFVO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzNHLE1BQU0sWUFBWSxHQUFHLE9BQU8sS0FBSyxDQUFDLFlBQVksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUM3RixJQUFJLENBQUMsWUFBWTtRQUFFLE9BQU8sSUFBSSxDQUFDO0lBQy9CLE1BQU0sT0FBTyxHQUFHLHlCQUF5QixDQUFDO1FBQ3hDLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUTtRQUN4QixRQUFRLEVBQUUsS0FBSyxDQUFDLFFBQVE7UUFDeEIsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO1FBQ3hCLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTTtLQUNyQixDQUFDLENBQUM7SUFDSCxJQUFJLENBQUMsT0FBTztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBQzFCLE1BQU0sS0FBSyxHQUFHLFdBQVcsQ0FBQyxXQUFXLENBQUMsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDL0YsMEdBQTBHO0lBQzFHLE1BQU0sY0FBYyxHQUFHLE9BQU8sT0FBTyxDQUFDLGNBQWMsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUN2RyxJQUFJLGNBQWMsRUFBRSxDQUFDO1FBQ25CLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyx3QkFBd0IsSUFBSSw2QkFBNkIsQ0FBQztRQUNuRixRQUFRLENBQ047WUFDRSx3QkFBd0IsQ0FBQztnQkFDdkIsY0FBYztnQkFDZCxZQUFZO2dCQUNaLFVBQVUsRUFBRSxPQUFPLENBQUMsUUFBUTtnQkFDNUIsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO2dCQUMxQixRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVE7YUFDM0IsQ0FBQztTQUNILEVBQ0QsRUFBRSxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUcsSUFBSSxPQUFPLENBQUMsR0FBRyxFQUFFLENBQ3BDLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUM1QixXQUFxRCxFQUNyRCxTQUFvRCxFQUFFO0lBRXRELE1BQU0sTUFBTSxHQUFHLFdBQVcsSUFBSSxPQUFPLFdBQVcsQ0FBQyxVQUFVLEtBQUssVUFBVSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7SUFDakgsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQWlFLENBQUM7SUFDeEYsS0FBSyxNQUFNLEtBQUssSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ3hELElBQUksQ0FBQyxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUTtZQUFFLFNBQVM7UUFDbEQsTUFBTSxHQUFHLEdBQUcsS0FBc0UsQ0FBQztRQUNuRixJQUFJLEdBQUcsQ0FBQyxJQUFJLEtBQUssc0JBQXNCO1lBQUUsU0FBUztRQUNsRCxJQUFJLE9BQU8sR0FBRyxDQUFDLFlBQVksS0FBSyxRQUFRLElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRTtZQUFFLFNBQVM7UUFDL0UsTUFBTSxVQUFVLEdBQUcseUJBQXlCLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzFELElBQUksQ0FBQyxVQUFVO1lBQUUsU0FBUztRQUMxQiw0R0FBNEc7UUFDNUcsK0dBQStHO1FBQy9HLDhHQUE4RztRQUM5RywyR0FBMkc7UUFDM0csK0dBQStHO1FBQy9HLE1BQU0sR0FBRyxHQUFHLEdBQUcsR0FBRyxDQUFDLFlBQVksSUFBSSxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDekQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNuQixNQUFNLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxFQUFFLEdBQUcsVUFBVSxFQUFFLFlBQVksRUFBRSxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9 \ No newline at end of file diff --git a/packages/loopover-miner/lib/pr-outcome.ts b/packages/loopover-miner/lib/pr-outcome.ts index 274df98712..ad78ddaf32 100644 --- a/packages/loopover-miner/lib/pr-outcome.ts +++ b/packages/loopover-miner/lib/pr-outcome.ts @@ -11,6 +11,11 @@ import { REJECTION_REASONS } from "./rejection-templates.js"; import type { AppendEventInput, LedgerEntry } from "./event-ledger.js"; +import { + buildAmsPrOutcomePayload, + scheduleAmsNotificationEvents, + type PublishAmsNotificationEventsOptions, +} from "./ams-notifications.js"; /** Event-ledger vocabulary for a miner-local PR outcome. */ export const MINER_PR_OUTCOME_EVENT = "pr_outcome" as const; @@ -40,6 +45,13 @@ export type RecordPrOutcomeOptions = { * writer throws `invalid_event_ledger` at runtime when this is absent or lacks `appendEvent`. Reuses the * real EventLedger#appendEvent signature so a genuine EventLedger (not just a same-shaped stub) type-checks. */ eventLedger?: { appendEvent(event: AppendEventInput): LedgerEntry }; + /** Recipient for AMS badge notify (#7657). When absent, notification is skipped (ledger write still happens). */ + recipientLogin?: string; + env?: Record; + scheduleAmsNotifications?: ( + events: Parameters[0], + options?: PublishAmsNotificationEventsOptions, + ) => void; }; export type PrOutcomeLedgerReader = { @@ -97,7 +109,25 @@ export function recordPrOutcomeSnapshot(input: PrOutcomeInput, options: RecordPr reason: input.reason, }); if (!payload) return null; - return eventLedger.appendEvent({ type: MINER_PR_OUTCOME_EVENT, repoFullName, payload }); + const entry = eventLedger.appendEvent({ type: MINER_PR_OUTCOME_EVENT, repoFullName, payload }); + // AMS badge notify (#7657): fire-and-forget when a recipient login is known (loop-cli passes minerLogin). + const recipientLogin = typeof options.recipientLogin === "string" ? options.recipientLogin.trim() : ""; + if (recipientLogin) { + const schedule = options.scheduleAmsNotifications ?? scheduleAmsNotificationEvents; + schedule( + [ + buildAmsPrOutcomePayload({ + recipientLogin, + repoFullName, + pullNumber: payload.prNumber, + decision: payload.decision, + closedAt: payload.closedAt, + }), + ], + { env: options.env ?? process.env }, + ); + } + return entry; } /** diff --git a/src/api/routes.ts b/src/api/routes.ts index 6df0b5be06..8f6e788bf3 100644 --- a/src/api/routes.ts +++ b/src/api/routes.ts @@ -283,7 +283,8 @@ import { attachDataQuality, buildCoreSignalFidelity, buildFreshnessSloReport, bu import { buildContributorOpenPrMonitor } from "../signals/contributor-open-pr-monitor"; import { buildContributorPrOutcomes } from "../signals/contributor-pr-outcomes"; import { buildReviewRiskExplanation } from "../signals/review-risk"; -import { buildNotificationFeed } from "../notifications/service"; +import { buildNotificationFeed, evaluateAndEnqueueNotificationDeliveries } from "../notifications/service"; +import { normalizeAmsNotificationEventInput } from "../notifications/ams-events"; import { buildPullRequestReviewability, type PullRequestReviewability } from "../signals/reward-risk"; import { buildLocalBranchAnalysis, findCurrentBranchPullRequest } from "../signals/local-branch"; import { buildIssueSlopAssessment } from "../signals/issue-slop"; @@ -467,6 +468,24 @@ const markNotificationsReadBodySchema = z.object({ ids: z.array(z.string().min(1).max(MAX_NOTIFICATION_DELIVERY_ID_LENGTH)).max(MAX_NOTIFICATION_MARK_READ_IDS).optional(), }); +// #7657: AMS miner posts DetectedNotificationEvent-shaped AMS kinds; recipient is forced to the path login. +const amsNotificationsBodySchema = z.object({ + events: z + .array( + z.object({ + eventType: z.enum(["ams_attempt_started", "ams_attempt_failed", "ams_governor_paused", "ams_pr_outcome"]), + repoFullName: z.string().min(1).max(200), + pullNumber: z.number().int().min(0), + dedupKey: z.string().min(1).max(500), + deeplink: z.string().min(1).max(2000), + actorLogin: z.string().min(1).max(100), + detectedAt: z.string().min(1).max(64), + }), + ) + .min(1) + .max(20), +}); + // #6746: body of POST/DELETE /v1/contributors/:login/watches. Mirrors watchIssuesShape (src/mcp/server.ts) minus // `login` (path param) and `action` (the HTTP verb). `labels` is POST-only (a DELETE ignores it). const watchSubscriptionBodySchema = z.object({ @@ -3517,6 +3536,27 @@ export function createApp() { return c.json({ login: login.toLowerCase(), marked }); }); + // #7657: AMS miner (or any self-scoped session) posts AMS-relevant notification events. Events are forced onto + // the path login and evaluated through evaluateAndEnqueueNotificationDeliveries — the same + // evaluateNotificationEvent → notify-deliver handoff job-dispatch.ts uses for webhook kinds. + app.post("/v1/contributors/:login/ams-notifications", async (c) => { + const login = c.req.param("login"); + const unauthorized = await requireContributorAccess(c, login); + if (unauthorized) return unauthorized; + const parsed = amsNotificationsBodySchema.safeParse(await c.req.json().catch(() => null)); + if (!parsed.success) return c.json({ error: "invalid_ams_notifications", issues: parsed.error.issues }, 400); + const events = parsed.data.events + .map((raw) => normalizeAmsNotificationEventInput(raw, login)) + .filter((event): event is NonNullable => event !== null); + if (events.length === 0) return c.json({ error: "invalid_ams_notifications", detail: "no_valid_events" }, 400); + const deliveries = await evaluateAndEnqueueNotificationDeliveries(c.env, events); + return c.json({ + login: login.toLowerCase(), + accepted: events.length, + enqueued: deliveries.length, + }); + }); + // #6746: REST mirror of the `loopover_watch_issues` MCP tool (LoopoverMcp.watchIssues) — manage a contributor's // own issue-watch subscriptions. The MCP tool's `action` enum splits across the HTTP verbs: GET=list, POST=watch, // DELETE=unwatch. Every verb is self-scoped via requireContributorAccess (a session may only touch its own diff --git a/src/db/schema.ts b/src/db/schema.ts index 56b16d01ea..d9ac9176dd 100644 --- a/src/db/schema.ts +++ b/src/db/schema.ts @@ -1126,6 +1126,9 @@ export const notificationSubscriptions = sqliteTable( }), ); +// event_type is free-text: webhook kinds (pull_request_changes_requested / pull_request_merged / +// issue_watch_match) plus AMS kinds (#7657: ams_attempt_started / ams_attempt_failed / +// ams_governor_paused / ams_pr_outcome). Subscriptions stay channel-scoped; kind filtering is at evaluate time. export const notificationDeliveries = sqliteTable( "notification_deliveries", { diff --git a/src/notifications/ams-events.ts b/src/notifications/ams-events.ts new file mode 100644 index 0000000000..01680940ea --- /dev/null +++ b/src/notifications/ams-events.ts @@ -0,0 +1,164 @@ +// AMS → badge notification bridge (#7657). Pure builders for DetectedNotificationEvent rows that the miner +// (and the session-authenticated ingest route) feed into evaluateNotificationEvent → notify-deliver — the same +// path job-dispatch.ts uses for webhook-detected kinds. No parallel delivery store. +// +// Payload/dedupKey shape is mirrored in packages/loopover-miner/lib/ams-notifications.ts (miner cannot import +// src/); keep the two builders in lockstep when changing eventType strings or dedupKey layout. + +import type { DetectedNotificationEvent, NotificationEventType } from "../types"; +import { nowIso } from "../utils/json"; + +export const AMS_NOTIFICATION_EVENT_TYPES = [ + "ams_attempt_started", + "ams_attempt_failed", + "ams_governor_paused", + "ams_pr_outcome", +] as const satisfies readonly NotificationEventType[]; + +export type AmsNotificationEventType = (typeof AMS_NOTIFICATION_EVENT_TYPES)[number]; + +const AMS_EVENT_TYPE_SET = new Set(AMS_NOTIFICATION_EVENT_TYPES); + +export function isAmsNotificationEventType(value: unknown): value is AmsNotificationEventType { + return typeof value === "string" && AMS_EVENT_TYPE_SET.has(value); +} + +function normalizeLogin(login: string): string { + return login.trim().toLowerCase(); +} + +function githubIssueDeeplink(repoFullName: string, issueNumber: number): string { + return `https://github.com/${repoFullName}/issues/${issueNumber}`; +} + +function githubPullDeeplink(repoFullName: string, pullNumber: number): string { + return `https://github.com/${repoFullName}/pull/${pullNumber}`; +} + +/** Attempt start — `pullNumber` carries the ISSUE number (same overload issue_watch_match uses). */ +export function buildAmsAttemptStartedEvent(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + detectedAt?: string; +}): DetectedNotificationEvent { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + return { + eventType: "ams_attempt_started", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_started:${input.repoFullName}#${input.issueNumber}:${input.attemptId}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +/** Attempt fail — same issue-number overload as start. */ +export function buildAmsAttemptFailedEvent(input: { + recipientLogin: string; + repoFullName: string; + issueNumber: number; + attemptId: string; + reason?: string | null; + detectedAt?: string; +}): DetectedNotificationEvent { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_attempt_failed", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.issueNumber, + dedupKey: `ams_attempt_failed:${input.repoFullName}#${input.issueNumber}:${input.attemptId}${reasonKey}`, + deeplink: githubIssueDeeplink(input.repoFullName, input.issueNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +/** + * Governor pause — not PR-scoped. `repoFullName` is a stable synthetic scope (`ams/governor`); `pullNumber` is 0. + */ +export function buildAmsGovernorPausedEvent(input: { + recipientLogin: string; + reason?: string | null; + pausedAt?: string; + detectedAt?: string; +}): DetectedNotificationEvent { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const pausedAt = input.pausedAt ?? detectedAt; + const reasonKey = input.reason?.trim() ? `:${input.reason.trim().slice(0, 80)}` : ""; + return { + eventType: "ams_governor_paused", + recipientLogin, + repoFullName: "ams/governor", + pullNumber: 0, + dedupKey: `ams_governor_paused:${recipientLogin}:${pausedAt}${reasonKey}`, + deeplink: "https://github.com/JSONbored/loopover", + actorLogin: recipientLogin, + detectedAt, + }; +} + +/** Miner-local PR outcome change (merged or closed). */ +export function buildAmsPrOutcomeEvent(input: { + recipientLogin: string; + repoFullName: string; + pullNumber: number; + decision: "merged" | "closed"; + closedAt?: string | null; + detectedAt?: string; +}): DetectedNotificationEvent { + const recipientLogin = normalizeLogin(input.recipientLogin); + const detectedAt = input.detectedAt ?? nowIso(); + const closedAt = input.closedAt?.trim() || detectedAt; + return { + eventType: "ams_pr_outcome", + recipientLogin, + repoFullName: input.repoFullName, + pullNumber: input.pullNumber, + // decision sits immediately after the eventType so buildAmsPrOutcomeNotification can read it without + // scanning an opaque middle segment (ams_pr_outcome:{merged|closed}:{repo}#{n}:{closedAt}). + dedupKey: `ams_pr_outcome:${input.decision}:${input.repoFullName}#${input.pullNumber}:${closedAt}`, + deeplink: githubPullDeeplink(input.repoFullName, input.pullNumber), + actorLogin: recipientLogin, + detectedAt, + }; +} + +/** + * Validate a miner-posted AMS event payload and stamp the authenticated recipient. Rejects non-AMS kinds so + * this ingest cannot forge webhook notification types. + */ +export function normalizeAmsNotificationEventInput( + raw: unknown, + recipientLogin: string, +): DetectedNotificationEvent | null { + if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null; + const record = raw as Record; + if (!isAmsNotificationEventType(record.eventType)) return null; + if (typeof record.repoFullName !== "string" || !record.repoFullName.trim()) return null; + if (typeof record.dedupKey !== "string" || !record.dedupKey.trim()) return null; + if (typeof record.deeplink !== "string" || !record.deeplink.trim()) return null; + if (typeof record.actorLogin !== "string" || !record.actorLogin.trim()) return null; + if (typeof record.detectedAt !== "string" || !record.detectedAt.trim()) return null; + if (!Number.isInteger(record.pullNumber) || (record.pullNumber as number) < 0) return null; + const login = normalizeLogin(recipientLogin); + return { + eventType: record.eventType, + recipientLogin: login, + repoFullName: record.repoFullName.trim(), + pullNumber: record.pullNumber as number, + dedupKey: record.dedupKey.trim(), + deeplink: record.deeplink.trim(), + // Force actor to the authenticated recipient — never trust a client-supplied actorLogin. + actorLogin: login, + detectedAt: record.detectedAt.trim(), + }; +} diff --git a/src/notifications/service.ts b/src/notifications/service.ts index 826e2de800..6f3f34a2b9 100644 --- a/src/notifications/service.ts +++ b/src/notifications/service.ts @@ -10,7 +10,13 @@ import { } from "../db/repositories"; import { isGrabbableHighMultiplierIssue } from "../signals/engine"; import { canLoginAccessRepo } from "../services/control-panel-roles"; -import type { DetectedNotificationEvent, IssueRecord, NotificationChannel, NotificationDeliveryRecord, NotificationSubscriptionRecord } from "../types"; +import type { + DetectedNotificationEvent, + IssueRecord, + NotificationChannel, + NotificationDeliveryRecord, + NotificationSubscriptionRecord, +} from "../types"; import { nowIso } from "../utils/json"; // Per-recipient, per-channel safety cap. The killer event (changes_requested) delivers immediately, but a @@ -54,6 +60,52 @@ export function buildIssueWatchNotification(event: DetectedNotificationEvent): { }; } +// AMS (#7657): attempt lifecycle — `pullNumber` carries the ISSUE number. Public-safe; no reward/trust figures. +export function buildAmsAttemptStartedNotification(event: DetectedNotificationEvent): { title: string; body: string } { + const ref = `${event.repoFullName}#${event.pullNumber}`; + return { + title: sanitizePublicComment(`Attempt started on ${ref}`), + body: sanitizePublicComment(`Your AMS miner started an attempt on ${ref}. Watch the attempt log for progress and the next decision.`), + }; +} + +export function buildAmsAttemptFailedNotification(event: DetectedNotificationEvent): { title: string; body: string } { + const ref = `${event.repoFullName}#${event.pullNumber}`; + return { + title: sanitizePublicComment(`Attempt failed on ${ref}`), + body: sanitizePublicComment(`Your AMS miner attempt on ${ref} did not complete successfully. Check the attempt log, then reclaim or pick the next high-fit issue.`), + }; +} + +export function buildAmsGovernorPausedNotification(_event: DetectedNotificationEvent): { title: string; body: string } { + return { + title: sanitizePublicComment("AMS governor paused"), + body: sanitizePublicComment( + "Your AMS governor is paused. New attempt cycles will wait until you resume with `loopover-miner governor resume`.", + ), + }; +} + +export function buildAmsPrOutcomeNotification(event: DetectedNotificationEvent): { title: string; body: string } { + const ref = `${event.repoFullName}#${event.pullNumber}`; + // dedupKey layout from buildAmsPrOutcomeEvent: ams_pr_outcome:{merged|closed}:{repo}#{n}:{closedAt} + const merged = event.dedupKey.startsWith("ams_pr_outcome:merged:"); + if (merged) { + return { + title: sanitizePublicComment(`AMS recorded merge: ${ref}`), + body: sanitizePublicComment( + `Your AMS miner recorded that ${ref} merged. Merged work strengthens your standing on ${event.repoFullName} — check your decision pack for the next high-fit issue.`, + ), + }; + } + return { + title: sanitizePublicComment(`AMS recorded close: ${ref}`), + body: sanitizePublicComment( + `Your AMS miner recorded that ${ref} closed without merge. Review the feedback, then pick the next high-fit issue on ${event.repoFullName}.`, + ), + }; +} + // Maps a detected event to its public-safe notification content. export function buildNotificationContent(event: DetectedNotificationEvent): { title: string; body: string } { switch (event.eventType) { @@ -61,11 +113,44 @@ export function buildNotificationContent(event: DetectedNotificationEvent): { ti return buildMergedOutcomeNotification(event); case "issue_watch_match": return buildIssueWatchNotification(event); - default: + case "ams_attempt_started": + return buildAmsAttemptStartedNotification(event); + case "ams_attempt_failed": + return buildAmsAttemptFailedNotification(event); + case "ams_governor_paused": + return buildAmsGovernorPausedNotification(event); + case "ams_pr_outcome": + return buildAmsPrOutcomeNotification(event); + case "pull_request_changes_requested": return buildChangesRequestedNotification(event); } } +/** + * Mirrors `job-dispatch.ts`'s notify-evaluate → notify-deliver handoff: evaluate each event, then enqueue one + * `notify-deliver` job per freshly-created pending delivery. Used by the AMS ingest route (#7657) and kept + * identical in shape to the queue processor so AMS kinds never take a parallel path. + */ +export async function evaluateAndEnqueueNotificationDeliveries( + env: Env, + events: DetectedNotificationEvent[], +): Promise { + const pending: NotificationDeliveryRecord[] = []; + for (const event of events) { + pending.push(...(await evaluateNotificationEvent(env, event))); + } + await Promise.all( + pending.map((delivery) => + env.JOBS.send({ + type: "notify-deliver", + requestedBy: "notify-evaluate", + deliveryId: delivery.id, + }), + ), + ); + return pending; +} + /** * #699 path B: when a webhook opens a NEW grabbable, high-multiplier issue, fan out one notification event * per watching miner (matching their optional label filter), skipping the issue's own author. DB-backed diff --git a/src/openapi/schemas.ts b/src/openapi/schemas.ts index 3796b8ff3c..3d90f80cb7 100644 --- a/src/openapi/schemas.ts +++ b/src/openapi/schemas.ts @@ -519,6 +519,14 @@ export const NotificationsMarkedSchema = z }) .openapi("NotificationsMarked"); +export const AmsNotificationsAcceptedSchema = z + .object({ + login: z.string(), + accepted: z.number(), + enqueued: z.number(), + }) + .openapi("AmsNotificationsAccepted"); + export const ContributorOpportunitySchema = z .object({ repoFullName: z.string(), diff --git a/src/openapi/spec.ts b/src/openapi/spec.ts index e6995b8842..114c8c6355 100644 --- a/src/openapi/spec.ts +++ b/src/openapi/spec.ts @@ -27,6 +27,7 @@ import { ContributorPrOutcomesSchema, NotificationFeedSchema, NotificationsMarkedSchema, + AmsNotificationsAcceptedSchema, ContributorRewardRiskStrategySchema, ContributorProfileSchema, ContributorScoringProfileSchema, @@ -830,6 +831,52 @@ export function buildOpenApiSpec() { 400: { description: "Invalid mark-read body" }, }, }); + registry.registerPath({ + method: "post", + path: "/v1/contributors/{login}/ams-notifications", + summary: "Enqueue AMS notification events for a contributor", + request: { + params: z.object({ login: z.string() }), + body: { + content: { + "application/json": { + // Inline Zod (not a registered components.schemas $ref) — matches every other request body in + // this generator so Cloudflare schema pruning stays response-free (#write-cloudflare-schema). + schema: z.object({ + events: z + .array( + z.object({ + eventType: z.enum([ + "ams_attempt_started", + "ams_attempt_failed", + "ams_governor_paused", + "ams_pr_outcome", + ]), + repoFullName: z.string(), + pullNumber: z.number().int().min(0), + dedupKey: z.string(), + deeplink: z.string(), + actorLogin: z.string(), + detectedAt: z.string(), + }), + ) + .min(1) + .max(20), + }), + }, + }, + }, + }, + responses: { + 200: { + description: + "Accepts AMS-relevant notification events (attempt start/fail, governor pause, PR outcome) and evaluates them through the existing notify-evaluate → notify-deliver path (#7657).", + content: { "application/json": { schema: AmsNotificationsAcceptedSchema } }, + }, + 400: { description: "Invalid AMS notification body" }, + 403: { description: "Forbidden when login does not match the authenticated session" }, + }, + }); registry.registerPath({ method: "get", path: "/v1/contributors/{login}/repos/{owner}/{repo}/decision", diff --git a/src/queue/job-dispatch.ts b/src/queue/job-dispatch.ts index cc6a9402b2..5b0c499529 100644 --- a/src/queue/job-dispatch.ts +++ b/src/queue/job-dispatch.ts @@ -272,6 +272,8 @@ export async function processJob(env: Env, message: JobMessage): Promise { const deliveries = ( await mapWithConcurrency(events, NOTIFY_EVALUATE_EVENT_CONCURRENCY, (event) => evaluateNotificationEvent(env, event)) ).flat(); + // Same notify-deliver handoff shape as evaluateAndEnqueueNotificationDeliveries (#7657) — keep the + // concurrency-bounded evaluate here for large webhook batches, then enqueue delivers identically. await Promise.all( deliveries.map((delivery) => env.JOBS.send({ diff --git a/src/types.ts b/src/types.ts index 8ec298c3fc..bec5189d99 100644 --- a/src/types.ts +++ b/src/types.ts @@ -189,7 +189,7 @@ export type JobMessage = // that was flooding the maintenance lane with a job per watcher on a popular newly-opened issue. Always // non-empty at enqueue time (see processors.ts); the processor evaluates every event in the batch. type: "notify-evaluate"; - requestedBy: "webhook" | "test"; + requestedBy: "webhook" | "ams" | "test"; events: DetectedNotificationEvent[]; } | { @@ -2384,7 +2384,16 @@ export type DigestSubscriptionRecord = { // unless a row is `paused`). export type NotificationChannel = "badge" | "email"; export type NotificationDeliveryStatus = "pending" | "delivered" | "read" | "suppressed"; -export type NotificationEventType = "pull_request_changes_requested" | "pull_request_merged" | "issue_watch_match"; +export type NotificationEventType = + | "pull_request_changes_requested" + | "pull_request_merged" + | "issue_watch_match" + // AMS-relevant kinds (#7657): attempt lifecycle, governor pause, and the miner's own PR-outcome change. + // Delivered through the same evaluateNotificationEvent → notify-deliver path as the webhook kinds above. + | "ams_attempt_started" + | "ams_attempt_failed" + | "ams_governor_paused" + | "ams_pr_outcome"; /** #699 path B: a miner's standing watch on a repo for new grabbable issues. `labels` ([]=any) filters * which issues notify. The `pullNumber` field of the resulting notification event carries the ISSUE number. */ diff --git a/test/unit/miner-ams-notifications.test.ts b/test/unit/miner-ams-notifications.test.ts new file mode 100644 index 0000000000..2e3087d731 --- /dev/null +++ b/test/unit/miner-ams-notifications.test.ts @@ -0,0 +1,153 @@ +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { afterEach, describe, expect, it, vi } from "vitest"; +import { + buildAmsAttemptFailedPayload, + buildAmsAttemptStartedPayload, + buildAmsGovernorPausedPayload, + buildAmsPrOutcomePayload, + publishAmsNotificationEvents, + scheduleAmsNotificationEvents, +} from "../../packages/loopover-miner/lib/ams-notifications.js"; + +const roots: string[] = []; + +afterEach(() => { + vi.restoreAllMocks(); + for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); +}); + +function writeSessionConfig(loginToken = "session-token"): { env: Record; root: string } { + const root = mkdtempSync(join(tmpdir(), "ams-notifications-config-")); + roots.push(root); + const configPath = join(root, "config.json"); + writeFileSync( + configPath, + JSON.stringify({ + activeProfile: "default", + profiles: { + default: { + apiUrl: "https://api.example.test", + session: { token: loginToken }, + }, + }, + }), + ); + return { env: { LOOPOVER_CONFIG_PATH: configPath }, root }; +} + +describe("ams-notifications (#7657)", () => { + it("builds AMS payloads mirroring hosted DetectedNotificationEvent shape", () => { + expect( + buildAmsAttemptStartedPayload({ + recipientLogin: "Miner", + repoFullName: "acme/widgets", + issueNumber: 2, + attemptId: "a1", + detectedAt: "2026-07-21T00:00:00.000Z", + }), + ).toMatchObject({ + eventType: "ams_attempt_started", + recipientLogin: "miner", + pullNumber: 2, + }); + expect( + buildAmsAttemptFailedPayload({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + issueNumber: 2, + attemptId: "a1", + reason: "abandon", + }).dedupKey, + ).toContain(":abandon"); + expect(buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" }).pullNumber).toBe(0); + expect( + buildAmsPrOutcomePayload({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + pullNumber: 9, + decision: "closed", + closedAt: "t", + }).eventType, + ).toBe("ams_pr_outcome"); + }); + + it("uses an injected dispatch (job-dispatch evaluate→deliver shape) when provided", async () => { + const dispatch = vi.fn(async () => undefined); + const event = buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" }); + await expect(publishAmsNotificationEvents([event], { dispatch })).resolves.toEqual({ sent: 1 }); + expect(dispatch).toHaveBeenCalledWith([event]); + }); + + it("returns no_session without a loopover backend session", async () => { + await expect( + publishAmsNotificationEvents([buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" })], { + env: { LOOPOVER_CONFIG_PATH: join(tmpdir(), "missing-loopover-config.json") }, + }), + ).resolves.toEqual({ sent: 0, error: "no_session" }); + }); + + it("POSTs to the contributor ams-notifications ingest when a session is present", async () => { + const { env } = writeSessionConfig(); + const fetchFn = vi.fn(async () => new Response(JSON.stringify({ accepted: 1 }), { status: 200 })); + const event = buildAmsAttemptStartedPayload({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + issueNumber: 1, + attemptId: "a1", + detectedAt: "2026-07-21T00:00:00.000Z", + }); + await expect(publishAmsNotificationEvents([event], { env, fetchFn })).resolves.toEqual({ sent: 1 }); + expect(fetchFn).toHaveBeenCalledWith( + "https://api.example.test/v1/contributors/miner/ams-notifications", + expect.objectContaining({ + method: "POST", + headers: expect.objectContaining({ authorization: "Bearer session-token" }), + }), + ); + }); + + it("reports http errors and mixed recipients on the HTTP path", async () => { + const { env } = writeSessionConfig(); + const fetchFn = vi.fn(async () => new Response("nope", { status: 500 })); + await expect( + publishAmsNotificationEvents([buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" })], { + env, + fetchFn, + }), + ).resolves.toEqual({ sent: 0, error: "http_500" }); + + await expect( + publishAmsNotificationEvents( + [ + buildAmsGovernorPausedPayload({ recipientLogin: "a", pausedAt: "t" }), + buildAmsGovernorPausedPayload({ recipientLogin: "b", pausedAt: "t" }), + ], + { env, fetchFn }, + ), + ).resolves.toEqual({ sent: 0, error: "mixed_recipients" }); + }); + + it("scheduleAmsNotificationEvents is fire-and-forget", async () => { + const dispatch = vi.fn(async () => undefined); + scheduleAmsNotificationEvents([buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" })], { + dispatch, + }); + await vi.waitFor(() => expect(dispatch).toHaveBeenCalled()); + }); + + it("reports dispatch failures without throwing", async () => { + await expect( + publishAmsNotificationEvents([buildAmsGovernorPausedPayload({ recipientLogin: "miner", pausedAt: "t" })], { + dispatch: async () => { + throw new Error("boom"); + }, + }), + ).resolves.toEqual({ sent: 0, error: "boom" }); + }); + + it("returns sent 0 for an empty event list", async () => { + await expect(publishAmsNotificationEvents([])).resolves.toEqual({ sent: 0 }); + }); +}); diff --git a/test/unit/miner-governor-pause-cli.test.ts b/test/unit/miner-governor-pause-cli.test.ts index d481780282..c643189fe3 100644 --- a/test/unit/miner-governor-pause-cli.test.ts +++ b/test/unit/miner-governor-pause-cli.test.ts @@ -92,6 +92,28 @@ describe("loopover-miner governor pause/resume/status CLI (#4851)", () => { expect(governorState.loadPauseState()).toEqual({ paused: false, reason: null, pausedAt: null }); }); + it("publishes an AMS governor-paused notification when a session login is available (#7657)", async () => { + const governorState = tempGovernorState(); + const published: Array<{ eventType: string; recipientLogin: string }> = []; + vi.spyOn(console, "log").mockImplementation(() => undefined); + + expect( + await runGovernorPause(["--reason", "ops", "--json"], { + openGovernorState: () => governorState, + publishAmsNotifications: async (events) => { + published.push(...(events as Array<{ eventType: string; recipientLogin: string }>)); + return { sent: events.length }; + }, + fetchSessionLogin: async () => "miner", + }), + ).toBe(0); + expect(published).toHaveLength(1); + expect(published[0]).toMatchObject({ + eventType: "ams_governor_paused", + recipientLogin: "miner", + }); + }); + it("pauses with no reason and renders the plain-text form", async () => { const governorState = tempGovernorState(); const log = vi.spyOn(console, "log").mockImplementation(() => undefined); diff --git a/test/unit/miner-pr-outcome.test.ts b/test/unit/miner-pr-outcome.test.ts index 5ae4cf293d..e0afe88e9b 100644 --- a/test/unit/miner-pr-outcome.test.ts +++ b/test/unit/miner-pr-outcome.test.ts @@ -1,4 +1,4 @@ -import { describe, expect, it } from "vitest"; +import { describe, expect, it, vi } from "vitest"; import { MINER_PR_OUTCOME_DECISIONS, MINER_PR_OUTCOME_EVENT, @@ -79,6 +79,21 @@ describe("recordPrOutcomeSnapshot (#4274)", () => { expect(entry.payload).toEqual({ prNumber: 12, decision: "closed", closedAt: "t", reason: "superseded_by_duplicate" }); expect(MINER_PR_OUTCOME_DECISIONS).toEqual(["merged", "closed"]); }); + + it("schedules an AMS pr-outcome notification when recipientLogin is provided (#7657)", () => { + const schedule = vi.fn(); + const ledger = mockLedger(); + recordPrOutcomeSnapshot( + { repoFullName: "acme/widgets", prNumber: 4, decision: "merged", closedAt: "2026-07-21T00:00:00.000Z" }, + { eventLedger: ledger, recipientLogin: "miner", scheduleAmsNotifications: schedule }, + ); + expect(schedule).toHaveBeenCalledOnce(); + expect(schedule.mock.calls[0]![0][0]).toMatchObject({ + eventType: "ams_pr_outcome", + recipientLogin: "miner", + pullNumber: 4, + }); + }); }); describe("readPrOutcomes (#4274)", () => { diff --git a/test/unit/notifications-ams-events.test.ts b/test/unit/notifications-ams-events.test.ts new file mode 100644 index 0000000000..d688faa47a --- /dev/null +++ b/test/unit/notifications-ams-events.test.ts @@ -0,0 +1,136 @@ +import { describe, expect, it } from "vitest"; +import { + buildAmsAttemptFailedEvent, + buildAmsAttemptStartedEvent, + buildAmsGovernorPausedEvent, + buildAmsPrOutcomeEvent, + isAmsNotificationEventType, + normalizeAmsNotificationEventInput, +} from "../../src/notifications/ams-events"; + +describe("AMS notification event builders (#7657)", () => { + it("builds attempt start/fail events with issue-number pullNumber overload", () => { + const started = buildAmsAttemptStartedEvent({ + recipientLogin: "Miner", + repoFullName: "acme/widgets", + issueNumber: 42, + attemptId: "a1", + detectedAt: "2026-07-21T00:00:00.000Z", + }); + expect(started).toMatchObject({ + eventType: "ams_attempt_started", + recipientLogin: "miner", + pullNumber: 42, + dedupKey: "ams_attempt_started:acme/widgets#42:a1", + deeplink: "https://github.com/acme/widgets/issues/42", + }); + + const failed = buildAmsAttemptFailedEvent({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + issueNumber: 42, + attemptId: "a1", + reason: "abandon", + detectedAt: "2026-07-21T00:00:00.000Z", + }); + expect(failed.eventType).toBe("ams_attempt_failed"); + expect(failed.dedupKey).toContain(":abandon"); + }); + + it("builds governor pause and pr-outcome events", () => { + const paused = buildAmsGovernorPausedEvent({ + recipientLogin: "miner", + reason: "ops", + pausedAt: "2026-07-21T00:00:00.000Z", + }); + expect(paused).toMatchObject({ + eventType: "ams_governor_paused", + repoFullName: "ams/governor", + pullNumber: 0, + }); + + const merged = buildAmsPrOutcomeEvent({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + pullNumber: 9, + decision: "merged", + closedAt: "2026-07-21T01:00:00.000Z", + }); + expect(merged.dedupKey).toContain("ams_pr_outcome:merged:"); + expect(merged.deeplink).toContain("/pull/9"); + + const closed = buildAmsPrOutcomeEvent({ + recipientLogin: "miner", + repoFullName: "acme/widgets", + pullNumber: 9, + decision: "closed", + closedAt: null, + detectedAt: "2026-07-21T02:00:00.000Z", + }); + expect(closed.dedupKey).toContain("ams_pr_outcome:closed:"); + }); + + it("normalizes ingest payloads and rejects non-AMS kinds", () => { + expect(isAmsNotificationEventType("ams_attempt_started")).toBe(true); + expect(isAmsNotificationEventType("pull_request_merged")).toBe(false); + + const ok = normalizeAmsNotificationEventInput( + { + eventType: "ams_attempt_started", + repoFullName: "acme/widgets", + pullNumber: 1, + dedupKey: "k", + deeplink: "https://example.com", + actorLogin: "spoofed", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + "Miner", + ); + expect(ok?.recipientLogin).toBe("miner"); + expect(ok?.actorLogin).toBe("miner"); + + expect(normalizeAmsNotificationEventInput(null, "miner")).toBeNull(); + expect( + normalizeAmsNotificationEventInput( + { + eventType: "pull_request_merged", + repoFullName: "acme/widgets", + pullNumber: 1, + dedupKey: "k", + deeplink: "https://example.com", + actorLogin: "miner", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + "miner", + ), + ).toBeNull(); + expect( + normalizeAmsNotificationEventInput( + { + eventType: "ams_attempt_started", + repoFullName: "", + pullNumber: 1, + dedupKey: "k", + deeplink: "https://example.com", + actorLogin: "miner", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + "miner", + ), + ).toBeNull(); + expect( + normalizeAmsNotificationEventInput( + { + eventType: "ams_attempt_started", + repoFullName: "acme/widgets", + pullNumber: -1, + dedupKey: "k", + deeplink: "https://example.com", + actorLogin: "miner", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + "miner", + ), + ).toBeNull(); + }); +}); diff --git a/test/unit/notifications-service.test.ts b/test/unit/notifications-service.test.ts index 9ac0ef9522..3ccbb34c8b 100644 --- a/test/unit/notifications-service.test.ts +++ b/test/unit/notifications-service.test.ts @@ -4,6 +4,7 @@ import { buildNotificationContent, buildNotificationFeed, deliverNotification, + evaluateAndEnqueueNotificationDeliveries, evaluateNotificationEvent, NOTIFICATION_RATE_LIMIT, resolveNotificationChannels, @@ -123,6 +124,80 @@ describe("merged-PR outcome attribution (#702)", () => { }); }); +describe("AMS notification event kinds (#7657)", () => { + it("builds public-safe copy for every AMS event kind (both pr-outcome branches)", () => { + const started = buildNotificationContent(event({ eventType: "ams_attempt_started", pullNumber: 12 })); + expect(started.title.toLowerCase()).toContain("attempt started"); + expect(started.body).toContain("owner/repo#12"); + + const failed = buildNotificationContent(event({ eventType: "ams_attempt_failed", pullNumber: 12 })); + expect(failed.title.toLowerCase()).toContain("attempt failed"); + + const paused = buildNotificationContent( + event({ eventType: "ams_governor_paused", repoFullName: "ams/governor", pullNumber: 0, dedupKey: "ams_governor_paused:miner:t" }), + ); + expect(paused.title.toLowerCase()).toContain("governor paused"); + expect(paused.body.toLowerCase()).toContain("resume"); + + const merged = buildNotificationContent( + event({ + eventType: "ams_pr_outcome", + dedupKey: "ams_pr_outcome:merged:owner/repo#7:2026-05-28T12:00:00.000Z", + }), + ); + expect(merged.title.toLowerCase()).toContain("merge"); + expect(JSON.stringify(merged)).not.toMatch(/reward|payout|trust score|wallet|\$/i); + + const closed = buildNotificationContent( + event({ + eventType: "ams_pr_outcome", + dedupKey: "ams_pr_outcome:closed:owner/repo#7:2026-05-28T12:00:00.000Z", + }), + ); + expect(closed.title.toLowerCase()).toContain("close"); + expect(closed.body.toLowerCase()).toContain("without merge"); + }); + + it("evaluates AMS events and enqueues notify-deliver jobs (job-dispatch handoff shape)", async () => { + const sent: Array<{ type: string; deliveryId?: string; requestedBy?: string }> = []; + const env = createTestEnv({ + JOBS: { + async send(message: { type: string; deliveryId?: string; requestedBy?: string }) { + sent.push(message); + }, + } as unknown as Queue, + }); + const deliveries = await evaluateAndEnqueueNotificationDeliveries(env, [ + event({ + eventType: "ams_attempt_started", + dedupKey: "ams_attempt_started:owner/repo#7:a1", + pullNumber: 7, + }), + event({ + eventType: "ams_governor_paused", + repoFullName: "ams/governor", + pullNumber: 0, + dedupKey: "ams_governor_paused:miner:t1", + }), + ]); + expect(deliveries).toHaveLength(2); + expect(sent).toEqual([ + { type: "notify-deliver", requestedBy: "notify-evaluate", deliveryId: deliveries[0]!.id }, + { type: "notify-deliver", requestedBy: "notify-evaluate", deliveryId: deliveries[1]!.id }, + ]); + }); + + it("returns no deliveries when the badge channel is paused", async () => { + const env = createTestEnv(); + await upsertNotificationSubscription(env, { login: "miner", channel: "badge", status: "paused", source: "test" }); + expect( + await evaluateAndEnqueueNotificationDeliveries(env, [ + event({ eventType: "ams_attempt_failed", dedupKey: "ams_attempt_failed:owner/repo#7:a1" }), + ]), + ).toEqual([]); + }); +}); + describe("evaluateNotificationEvent", () => { it("creates exactly one badge delivery and is idempotent on a duplicate event", async () => { const env = createTestEnv(); diff --git a/test/unit/routes-ams-notifications.test.ts b/test/unit/routes-ams-notifications.test.ts new file mode 100644 index 0000000000..07e8ee026e --- /dev/null +++ b/test/unit/routes-ams-notifications.test.ts @@ -0,0 +1,94 @@ +import { describe, expect, it } from "vitest"; +import { createApp } from "../../src/api/routes"; +import { listNotificationDeliveriesForRecipient } from "../../src/db/repositories"; +import { createTestEnv } from "../helpers/d1"; + +// Operator API token (same posture as routes-notifications.test.ts) — requireContributorAccess allows the +// static `api` identity to post AMS events for any login; session callers need ADMIN_GITHUB_LOGINS first. +const jsonHeaders = (env: Env) => ({ + authorization: `Bearer ${env.LOOPOVER_API_TOKEN}`, + "content-type": "application/json", +}); + +describe("POST /v1/contributors/:login/ams-notifications (#7657)", () => { + it("evaluates AMS events through the existing notify-deliver path", async () => { + const sent: Array<{ type: string; deliveryId?: string; requestedBy?: string }> = []; + const env = createTestEnv({ + JOBS: { + async send(message: { type: string; deliveryId?: string; requestedBy?: string }) { + sent.push(message); + }, + } as unknown as Queue, + }); + const app = createApp(); + + const response = await app.request( + "/v1/contributors/miner/ams-notifications", + { + method: "POST", + headers: jsonHeaders(env), + body: JSON.stringify({ + events: [ + { + eventType: "ams_attempt_started", + repoFullName: "acme/widgets", + pullNumber: 3, + dedupKey: "ams_attempt_started:acme/widgets#3:a1", + deeplink: "https://github.com/acme/widgets/issues/3", + actorLogin: "miner", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + ], + }), + }, + env, + ); + expect(response.status).toBe(200); + const body = (await response.json()) as { accepted: number; enqueued: number; login: string }; + expect(body).toEqual({ login: "miner", accepted: 1, enqueued: 1 }); + expect(sent).toEqual([{ type: "notify-deliver", requestedBy: "notify-evaluate", deliveryId: expect.any(String) }]); + + const deliveries = await listNotificationDeliveriesForRecipient(env, "miner", { eventType: "ams_attempt_started" }); + expect(deliveries).toHaveLength(1); + expect(deliveries[0]).toMatchObject({ eventType: "ams_attempt_started", pullNumber: 3, status: "pending" }); + }); + + it("rejects forged webhook event kinds and invalid bodies", async () => { + const env = createTestEnv(); + const app = createApp(); + + const forged = await app.request( + "/v1/contributors/miner/ams-notifications", + { + method: "POST", + headers: jsonHeaders(env), + body: JSON.stringify({ + events: [ + { + eventType: "pull_request_merged", + repoFullName: "acme/widgets", + pullNumber: 1, + dedupKey: "x", + deeplink: "https://example.com", + actorLogin: "miner", + detectedAt: "2026-07-21T00:00:00.000Z", + }, + ], + }), + }, + env, + ); + expect(forged.status).toBe(400); + + const empty = await app.request( + "/v1/contributors/miner/ams-notifications", + { + method: "POST", + headers: jsonHeaders(env), + body: JSON.stringify({ events: [] }), + }, + env, + ); + expect(empty.status).toBe(400); + }); +});