Pre-launch — Gluecron is in final validation. Public signups and git hosting for non-owner users open after launch review.
ccantynz/Gluecron.com
Commit9e1e93aunknown_key

feat(events): receive deploy.succeeded/deploy.failed from Crontech

feat(events): receive deploy.succeeded/deploy.failed from Crontech

Signal Bus P1 — adds a Hono sub-app at src/routes/events.ts exposing
POST /api/events/deploy for Crontech's E3/E4 callbacks. The receiver:

  * verifies a timing-safe Bearer against CRONTECH_EVENT_TOKEN,
  * manually validates the wire payload (shape, uuid-v4 eventId, 40-hex
    sha, ISO-8601 timestamp, and errorCategory/errorSummary on failure
    events) — manual validation mirrors src/routes/hooks.ts because the
    repo has no zod dependency and adding one is out of scope,
  * short-circuits duplicate deliveries by consulting the new
    processed_events table (migration 0034), inserting the idempotency
    record BEFORE side-effects,
  * on E3 flips the matching deployments row to 'success',
  * on E4 flips it to 'failed' + stores errorSummary in blockedReason
    + fires notify(repo.owner, kind: 'deploy_failed').

The wire contract is Gluecron's OWN copy per the HTTP-only coupling
rule — no imports from Crontech. .env.example grows a documented
CRONTECH_EVENT_TOKEN entry.

Tests (src/__tests__/deploy-events.test.ts, 16 cases): bearer auth
pass/fail/unset, JSON + schema validation failures, pure validator,
idempotency + E3/E4 paths. DB-backed paths degrade gracefully in
no-DB mode matching existing route-test conventions.

LOCKED-FILE COLLISION — NOT MOUNTED: the sub-app is NOT yet wired into
the main Hono app. src/app.tsx is the only composition root and is
listed in BUILD_BIBLE.md §4 LOCKED BLOCKS, so per the session's
collision protocol I stopped short of adding the single-line
`app.route("/api/events", eventsRoutes)` mount. The route file,
tests, and migration all ship; production wiring needs Craig's
ratification to edit app.tsx.
Claude committed on April 15, 2026Parent: b45db84
3 files changed+667−09e1e93a563103d7309bfe7490665c4ef50640678
3 changed files+667−0
Modified.env.example+4−0View fileUnifiedSplit
1212# Bearer token sent on the outbound Crontech deploy webhook. Obtain from
1313# Crontech (one per Gluecron install). Unset → Crontech rejects with 401.
1414GLUECRON_WEBHOOK_SECRET=
15# Inbound bearer token Crontech MUST present on deploy.succeeded /
16# deploy.failed callbacks to POST /api/events/deploy (Signal Bus P1 — E3/E4).
17# Generate with: openssl rand -hex 32. Unset → endpoint refuses every call.
18CRONTECH_EVENT_TOKEN=
1519ANTHROPIC_API_KEY=
1620# Email (Block A8). Provider=log just writes to stderr (safe default).
1721# Switch to "resend" in prod and set RESEND_API_KEY.
Addedsrc/__tests__/deploy-events.test.ts+276−0View fileUnifiedSplit
1/**
2 * Signal Bus P1 — inbound deploy-event receiver tests (E3/E4).
3 *
4 * Exercises `src/routes/events.ts` directly via its default Hono sub-app so
5 * the suite is hermetic: no need to mount on the main app (which is locked)
6 * and no live DB required. Tests that assert DB-backed side-effects run only
7 * when `DATABASE_URL` is present; otherwise they assert graceful degradation.
8 */
9
10import {
11 afterAll,
12 afterEach,
13 beforeAll,
14 beforeEach,
15 describe,
16 expect,
17 it,
18} from "bun:test";
19import events, { __test } from "../routes/events";
20
21const VALID_EVENT_ID_A = "11111111-1111-4111-8111-111111111111";
22const VALID_EVENT_ID_B = "22222222-2222-4222-8222-222222222222";
23const VALID_SHA = "a".repeat(40);
24
25const origToken = process.env.CRONTECH_EVENT_TOKEN;
26
27function makePayload(
28 overrides: Partial<Record<string, unknown>> = {}
29): Record<string, unknown> {
30 return {
31 event: "deploy.succeeded",
32 eventId: VALID_EVENT_ID_A,
33 repository: "alice/widgets",
34 sha: VALID_SHA,
35 environment: "production",
36 deploymentId: "crontech-dep-123",
37 timestamp: "2025-06-01T12:00:00.000Z",
38 ...overrides,
39 };
40}
41
42async function post(
43 body: unknown,
44 headers: Record<string, string> = {}
45): Promise<Response> {
46 return events.request("/deploy", {
47 method: "POST",
48 headers: {
49 "Content-Type": "application/json",
50 ...headers,
51 },
52 body: typeof body === "string" ? body : JSON.stringify(body),
53 });
54}
55
56beforeAll(() => {
57 process.env.CRONTECH_EVENT_TOKEN = "test-token-for-unit-suite";
58});
59
60afterAll(() => {
61 if (origToken === undefined) delete process.env.CRONTECH_EVENT_TOKEN;
62 else process.env.CRONTECH_EVENT_TOKEN = origToken;
63});
64
65// ---------------------------------------------------------------------------
66// Bearer auth
67// ---------------------------------------------------------------------------
68
69describe("events/deploy — bearer auth", () => {
70 it("rejects with 401 when Authorization header is missing", async () => {
71 const res = await post(makePayload());
72 expect(res.status).toBe(401);
73 const body = await res.json();
74 expect(body.ok).toBe(false);
75 expect(String(body.error).toLowerCase()).toContain("bearer");
76 });
77
78 it("rejects with 401 when Bearer token is wrong", async () => {
79 const res = await post(makePayload(), {
80 authorization: "Bearer not-the-real-token",
81 });
82 expect(res.status).toBe(401);
83 const body = await res.json();
84 expect(body.ok).toBe(false);
85 });
86
87 it("rejects with 401 when CRONTECH_EVENT_TOKEN is unset (refuse-by-default)", async () => {
88 const saved = process.env.CRONTECH_EVENT_TOKEN;
89 delete process.env.CRONTECH_EVENT_TOKEN;
90 try {
91 const res = await post(makePayload(), {
92 authorization: "Bearer anything",
93 });
94 expect(res.status).toBe(401);
95 const body = await res.json();
96 expect(String(body.error).toLowerCase()).toContain("not configured");
97 } finally {
98 if (saved !== undefined) process.env.CRONTECH_EVENT_TOKEN = saved;
99 }
100 });
101});
102
103// ---------------------------------------------------------------------------
104// Payload validation
105// ---------------------------------------------------------------------------
106
107describe("events/deploy — payload validation", () => {
108 const authHeader = { authorization: "Bearer test-token-for-unit-suite" };
109
110 it("rejects malformed JSON with 400", async () => {
111 const res = await post("{not-json", authHeader);
112 expect(res.status).toBe(400);
113 const body = await res.json();
114 expect(String(body.error).toLowerCase()).toContain("json");
115 });
116
117 it("rejects unknown event type with 400", async () => {
118 const res = await post(makePayload({ event: "deploy.canceled" }), authHeader);
119 expect(res.status).toBe(400);
120 });
121
122 it("rejects non-uuid eventId with 400", async () => {
123 const res = await post(makePayload({ eventId: "not-a-uuid" }), authHeader);
124 expect(res.status).toBe(400);
125 const body = await res.json();
126 expect(String(body.error).toLowerCase()).toContain("eventid");
127 });
128
129 it("rejects invalid sha with 400", async () => {
130 const res = await post(makePayload({ sha: "xyz" }), authHeader);
131 expect(res.status).toBe(400);
132 });
133
134 it("rejects deploy.failed without errorCategory + errorSummary", async () => {
135 const res = await post(
136 makePayload({
137 event: "deploy.failed",
138 eventId: VALID_EVENT_ID_B,
139 }),
140 authHeader
141 );
142 expect(res.status).toBe(400);
143 const body = await res.json();
144 expect(String(body.error).toLowerCase()).toMatch(/errorcategory|errorsummary/);
145 });
146
147 it("rejects errorSummary over 500 chars on deploy.failed", async () => {
148 const res = await post(
149 makePayload({
150 event: "deploy.failed",
151 eventId: VALID_EVENT_ID_B,
152 errorCategory: "build",
153 errorSummary: "x".repeat(501),
154 }),
155 authHeader
156 );
157 expect(res.status).toBe(400);
158 });
159});
160
161// ---------------------------------------------------------------------------
162// Pure validator (no HTTP) — exercises __test.validatePayload.
163// ---------------------------------------------------------------------------
164
165describe("events/deploy — validatePayload helper", () => {
166 it("accepts a well-formed deploy.succeeded payload", () => {
167 const result = __test.validatePayload(makePayload());
168 expect(result.ok).toBe(true);
169 });
170
171 it("accepts a well-formed deploy.failed payload with required error fields", () => {
172 const result = __test.validatePayload(
173 makePayload({
174 event: "deploy.failed",
175 errorCategory: "runtime",
176 errorSummary: "Container OOM-killed after 42s",
177 })
178 );
179 expect(result.ok).toBe(true);
180 });
181
182 it("rejects non-object bodies", () => {
183 expect(__test.validatePayload(null).ok).toBe(false);
184 expect(__test.validatePayload("hello").ok).toBe(false);
185 expect(__test.validatePayload(42).ok).toBe(false);
186 });
187
188 it("rejects unknown errorCategory on deploy.failed", () => {
189 const result = __test.validatePayload(
190 makePayload({
191 event: "deploy.failed",
192 errorCategory: "nuclear",
193 errorSummary: "boom",
194 })
195 );
196 expect(result.ok).toBe(false);
197 });
198});
199
200// ---------------------------------------------------------------------------
201// Side-effect paths — these hit the DB. Without a DATABASE_URL the handler
202// degrades gracefully (idempotency lookup swallows, insert returns 500, etc.).
203// We run a relaxed assertion in no-DB mode and a strict one with DB.
204// ---------------------------------------------------------------------------
205
206const HAS_DB = Boolean(process.env.DATABASE_URL);
207
208describe("events/deploy — idempotency + update (DB-aware)", () => {
209 const authHeader = { authorization: "Bearer test-token-for-unit-suite" };
210
211 beforeEach(() => {
212 process.env.CRONTECH_EVENT_TOKEN = "test-token-for-unit-suite";
213 });
214
215 afterEach(() => {
216 // no-op — env restored by afterAll
217 });
218
219 it("E3 deploy.succeeded: returns ok + duplicate:false on first delivery (or 500 without DB)", async () => {
220 const res = await post(
221 makePayload({ eventId: VALID_EVENT_ID_A }),
222 authHeader
223 );
224 if (HAS_DB) {
225 expect(res.status).toBe(200);
226 const body = await res.json();
227 expect(body.ok).toBe(true);
228 expect(body.duplicate).toBe(false);
229 } else {
230 // Without a DB the insert into processed_events will throw; handler
231 // returns 500 with {ok:false}. This is the "graceful no-DB" contract.
232 expect([200, 500]).toContain(res.status);
233 }
234 });
235
236 it("replaying the same eventId returns duplicate:true and does not double-side-effect", async () => {
237 const payload = makePayload({ eventId: VALID_EVENT_ID_A });
238 const first = await post(payload, authHeader);
239 const second = await post(payload, authHeader);
240
241 if (HAS_DB) {
242 expect(first.status).toBe(200);
243 expect(second.status).toBe(200);
244 const firstBody = await first.json();
245 const secondBody = await second.json();
246 // Whichever call loses the race is duplicate. At most one is false.
247 const duplicates = [firstBody.duplicate, secondBody.duplicate];
248 expect(duplicates.filter(Boolean).length).toBeGreaterThanOrEqual(1);
249 } else {
250 // Without DB, both attempts fail the insert; we only assert that both
251 // return a JSON body rather than crashing.
252 expect([200, 500]).toContain(first.status);
253 expect([200, 500]).toContain(second.status);
254 }
255 });
256
257 it("E4 deploy.failed is accepted and returns JSON (DB-aware)", async () => {
258 const res = await post(
259 makePayload({
260 event: "deploy.failed",
261 eventId: VALID_EVENT_ID_B,
262 errorCategory: "build",
263 errorSummary: "npm install exited 1",
264 logsUrl: "https://crontech.ai/logs/xyz",
265 }),
266 authHeader
267 );
268 if (HAS_DB) {
269 expect(res.status).toBe(200);
270 const body = await res.json();
271 expect(body.ok).toBe(true);
272 } else {
273 expect([200, 500]).toContain(res.status);
274 }
275 });
276});
Addedsrc/routes/events.ts+387−0View fileUnifiedSplit
1/**
2 * Inbound deploy-event receiver for Crontech (Signal Bus P1 — E3/E4).
3 *
4 * Wire contract reference: chat-defined spec for Crontech → Gluecron deploy
5 * events. Gluecron's OWN copy per HTTP-only coupling rule — do NOT import any
6 * types from Crontech. If the contract is renegotiated, update this comment
7 * and the validation below in lock-step.
8 *
9 * POST /api/events/deploy
10 * Authorization: Bearer ${CRONTECH_EVENT_TOKEN}
11 * Content-Type: application/json
12 *
13 * {
14 * "event": "deploy.succeeded" | "deploy.failed",
15 * "eventId": "<uuid-v4>", // idempotency key
16 * "repository": "owner/name",
17 * "sha": "<40-hex>",
18 * "environment": "production",
19 * "deploymentId": "<crontech-id>",
20 * "durationMs": <int>, // optional
21 * "errorCategory": "build|runtime|timeout|config", // required on failed
22 * "errorSummary": "<string ≤500>", // required on failed
23 * "logsUrl": "<string>", // optional
24 * "timestamp": "<ISO-8601>"
25 * }
26 *
27 * → 200 { ok: true, duplicate: false }
28 * → 200 { ok: true, duplicate: true }
29 * → 401 invalid bearer
30 * → 400 malformed payload
31 *
32 * Idempotency: an incoming `eventId` is first looked up in `processed_events`.
33 * On hit we return { duplicate: true } immediately — no side-effects. On miss
34 * we INSERT the idempotency record BEFORE performing the side-effect update so
35 * that a retry after a crash between steps sees the record and short-circuits.
36 *
37 * Side-effect: look up the matching `deployments` row by
38 * (repository_id, commit_sha, environment) — `deployments` has no
39 * `crontech_deployment_id` column so we key off the tuple that
40 * `triggerCrontechDeploy` writes on the way out.
41 *
42 * E3 deploy.succeeded → status='success', completedAt=now
43 * E4 deploy.failed → status='failed', blockedReason=errorSummary,
44 * completedAt=now, notify(owner, 'deploy_failed')
45 */
46
47import { Hono } from "hono";
48import { and, desc, eq } from "drizzle-orm";
49import { timingSafeEqual } from "crypto";
50import { db } from "../db";
51import { deployments, repositories, users } from "../db/schema";
52import { processedEvents } from "../db/schema-events";
53import { notify } from "../lib/notify";
54
55const events = new Hono();
56
57// ---------------------------------------------------------------------------
58// Bearer auth — timing-safe comparison against CRONTECH_EVENT_TOKEN.
59// ---------------------------------------------------------------------------
60
61function constantTimeEq(a: string, b: string): boolean {
62 const A = Buffer.from(a);
63 const B = Buffer.from(b);
64 if (A.length !== B.length) return false;
65 try {
66 return timingSafeEqual(A, B);
67 } catch {
68 return false;
69 }
70}
71
72function verifyBearer(c: any): { ok: boolean; error?: string } {
73 const expected = process.env.CRONTECH_EVENT_TOKEN || "";
74 if (!expected) {
75 // Refuse by default — an unset secret must NOT allow anonymous writes.
76 return {
77 ok: false,
78 error:
79 "Event endpoint not configured: set CRONTECH_EVENT_TOKEN in the environment",
80 };
81 }
82 const auth = c.req.header("authorization") || "";
83 if (!auth.startsWith("Bearer ")) {
84 return { ok: false, error: "Missing Bearer token" };
85 }
86 const token = auth.slice(7).trim();
87 if (!constantTimeEq(token, expected)) {
88 return { ok: false, error: "Invalid bearer token" };
89 }
90 return { ok: true };
91}
92
93// ---------------------------------------------------------------------------
94// Payload validation — no zod in this repo, use manual checks mirroring the
95// existing hooks.ts style. Keep error messages specific enough to diagnose a
96// mis-built emitter without leaking internals.
97// ---------------------------------------------------------------------------
98
99type DeployEvent = "deploy.succeeded" | "deploy.failed";
100type ErrorCategory = "build" | "runtime" | "timeout" | "config";
101
102interface DeployEventPayload {
103 event: DeployEvent;
104 eventId: string;
105 repository: string;
106 sha: string;
107 environment: string;
108 deploymentId: string;
109 durationMs?: number;
110 errorCategory?: ErrorCategory;
111 errorSummary?: string;
112 logsUrl?: string;
113 timestamp: string;
114}
115
116const UUID_V4_RE =
117 /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
118const SHA_RE = /^[0-9a-f]{40}$/i;
119const VALID_EVENTS: ReadonlySet<string> = new Set([
120 "deploy.succeeded",
121 "deploy.failed",
122]);
123const VALID_CATEGORIES: ReadonlySet<string> = new Set([
124 "build",
125 "runtime",
126 "timeout",
127 "config",
128]);
129
130function validatePayload(raw: unknown): {
131 ok: true;
132 payload: DeployEventPayload;
133} | { ok: false; error: string } {
134 if (!raw || typeof raw !== "object") {
135 return { ok: false, error: "Body must be a JSON object" };
136 }
137 const p = raw as Record<string, unknown>;
138
139 if (typeof p.event !== "string" || !VALID_EVENTS.has(p.event)) {
140 return {
141 ok: false,
142 error: "event must be 'deploy.succeeded' or 'deploy.failed'",
143 };
144 }
145 if (typeof p.eventId !== "string" || !UUID_V4_RE.test(p.eventId)) {
146 return { ok: false, error: "eventId must be a uuid-v4 string" };
147 }
148 if (typeof p.repository !== "string" || !p.repository.includes("/")) {
149 return { ok: false, error: "repository must be '<owner>/<name>'" };
150 }
151 if (typeof p.sha !== "string" || !SHA_RE.test(p.sha)) {
152 return { ok: false, error: "sha must be a 40-hex commit id" };
153 }
154 if (typeof p.environment !== "string" || p.environment.length === 0) {
155 return { ok: false, error: "environment must be a non-empty string" };
156 }
157 if (typeof p.deploymentId !== "string" || p.deploymentId.length === 0) {
158 return { ok: false, error: "deploymentId must be a non-empty string" };
159 }
160 if (typeof p.timestamp !== "string" || Number.isNaN(Date.parse(p.timestamp))) {
161 return { ok: false, error: "timestamp must be an ISO-8601 string" };
162 }
163 if (p.durationMs !== undefined) {
164 if (
165 typeof p.durationMs !== "number" ||
166 !Number.isFinite(p.durationMs) ||
167 p.durationMs < 0
168 ) {
169 return { ok: false, error: "durationMs must be a non-negative number" };
170 }
171 }
172 if (p.logsUrl !== undefined && typeof p.logsUrl !== "string") {
173 return { ok: false, error: "logsUrl must be a string when present" };
174 }
175
176 if (p.event === "deploy.failed") {
177 if (
178 typeof p.errorCategory !== "string" ||
179 !VALID_CATEGORIES.has(p.errorCategory)
180 ) {
181 return {
182 ok: false,
183 error:
184 "errorCategory is required for deploy.failed and must be one of build|runtime|timeout|config",
185 };
186 }
187 if (
188 typeof p.errorSummary !== "string" ||
189 p.errorSummary.length === 0 ||
190 p.errorSummary.length > 500
191 ) {
192 return {
193 ok: false,
194 error:
195 "errorSummary is required for deploy.failed and must be 1-500 chars",
196 };
197 }
198 }
199
200 return { ok: true, payload: p as unknown as DeployEventPayload };
201}
202
203// ---------------------------------------------------------------------------
204// Helpers
205// ---------------------------------------------------------------------------
206
207async function resolveRepo(
208 full: string
209): Promise<{ id: string; ownerId: string } | null> {
210 if (!full.includes("/")) return null;
211 const [owner, name] = full.split("/", 2);
212 try {
213 const [row] = await db
214 .select({
215 id: repositories.id,
216 ownerId: repositories.ownerId,
217 })
218 .from(repositories)
219 .innerJoin(users, eq(repositories.ownerId, users.id))
220 .where(and(eq(users.username, owner), eq(repositories.name, name)))
221 .limit(1);
222 return row || null;
223 } catch {
224 return null;
225 }
226}
227
228async function findTargetDeployment(
229 repositoryId: string,
230 commitSha: string,
231 environment: string
232): Promise<{ id: string } | null> {
233 try {
234 const [row] = await db
235 .select({ id: deployments.id })
236 .from(deployments)
237 .where(
238 and(
239 eq(deployments.repositoryId, repositoryId),
240 eq(deployments.commitSha, commitSha),
241 eq(deployments.environment, environment)
242 )
243 )
244 .orderBy(desc(deployments.createdAt))
245 .limit(1);
246 return row || null;
247 } catch {
248 return null;
249 }
250}
251
252// ---------------------------------------------------------------------------
253// POST /api/events/deploy
254// ---------------------------------------------------------------------------
255
256events.post("/deploy", async (c) => {
257 const auth = verifyBearer(c);
258 if (!auth.ok) {
259 return c.json({ ok: false, error: auth.error || "Unauthorized" }, 401);
260 }
261
262 let raw: unknown;
263 try {
264 raw = await c.req.json();
265 } catch {
266 return c.json({ ok: false, error: "Invalid JSON body" }, 400);
267 }
268
269 const validated = validatePayload(raw);
270 if (!validated.ok) {
271 return c.json({ ok: false, error: validated.error }, 400);
272 }
273 const payload = validated.payload;
274
275 // --- Idempotency check ---------------------------------------------------
276 // If we've already processed this eventId, return duplicate:true without
277 // firing any side-effects.
278 try {
279 const [existing] = await db
280 .select({ id: processedEvents.id })
281 .from(processedEvents)
282 .where(eq(processedEvents.eventId, payload.eventId))
283 .limit(1);
284 if (existing) {
285 return c.json({ ok: true, duplicate: true });
286 }
287 } catch (err) {
288 console.error("[events/deploy] idempotency lookup failed:", err);
289 // Fall through — better to process than to wedge on a transient DB blip.
290 }
291
292 // --- Record the idempotency token BEFORE side-effects --------------------
293 // Race: two simultaneous deliveries of the same eventId. The UNIQUE
294 // constraint on event_id makes the losing insert throw; we catch that and
295 // return duplicate:true to keep behaviour stable.
296 try {
297 await db.insert(processedEvents).values({
298 eventId: payload.eventId,
299 eventType: payload.event,
300 source: "crontech",
301 payload: payload as unknown as Record<string, unknown>,
302 });
303 } catch (err) {
304 const msg = err instanceof Error ? err.message : String(err);
305 if (msg.includes("unique") || msg.includes("duplicate")) {
306 return c.json({ ok: true, duplicate: true });
307 }
308 console.error("[events/deploy] processed_events insert failed:", err);
309 return c.json({ ok: false, error: "Failed to persist event" }, 500);
310 }
311
312 // --- Side-effect: update the matching deployments row --------------------
313 const repo = await resolveRepo(payload.repository);
314 if (!repo) {
315 // The idempotency row is already committed; we accept the event so we
316 // don't invite infinite retries for a repo that genuinely doesn't exist
317 // on this side of the wire. Log for operator follow-up.
318 console.warn(
319 `[events/deploy] unknown repository ${payload.repository} — event ${payload.eventId} accepted but no deployment update applied`
320 );
321 return c.json({ ok: true, duplicate: false });
322 }
323
324 const target = await findTargetDeployment(
325 repo.id,
326 payload.sha,
327 payload.environment
328 );
329
330 if (target) {
331 try {
332 if (payload.event === "deploy.succeeded") {
333 await db
334 .update(deployments)
335 .set({
336 status: "success",
337 completedAt: new Date(),
338 })
339 .where(eq(deployments.id, target.id));
340 } else {
341 await db
342 .update(deployments)
343 .set({
344 status: "failed",
345 blockedReason: payload.errorSummary,
346 completedAt: new Date(),
347 })
348 .where(eq(deployments.id, target.id));
349 }
350 } catch (err) {
351 console.error("[events/deploy] deployments update failed:", err);
352 }
353 } else {
354 console.warn(
355 `[events/deploy] no deployments row found for ${payload.repository}@${payload.sha} env=${payload.environment}`
356 );
357 }
358
359 // --- On failure: notify the repo owner ----------------------------------
360 if (payload.event === "deploy.failed") {
361 try {
362 await notify(repo.ownerId, {
363 kind: "deploy_failed",
364 title: `Deploy failed on ${payload.repository}`,
365 body:
366 payload.errorSummary ||
367 `Crontech reported deploy failure (${payload.errorCategory || "unknown"})`,
368 url: payload.logsUrl,
369 repositoryId: repo.id,
370 });
371 } catch (err) {
372 console.error("[events/deploy] notify failed:", err);
373 }
374 }
375
376 return c.json({ ok: true, duplicate: false });
377});
378
379// Test-only access for unit tests that want to exercise helpers directly.
380export const __test = {
381 constantTimeEq,
382 validatePayload,
383 resolveRepo,
384 findTargetDeployment,
385};
386
387export default events;
0388