import { WorkerEntrypoint } from "cloudflare:workers"; import { approvePipeline, cancelPipeline, notifyEvent, retryPipeline } from "./notify"; import docs from "../docs/workflows.md"; import { subscribePipelineLogs } from "./logs"; import { getPipeline, getWorkflowDefinition, listWorkflowDefinitions, queryPipelines, } from "./pipelines"; import { secretXrpc } from "./secrets"; import { buildkiteWebhook } from "./webhook"; import { webhookXrpc } from "./webhooks"; import { rateLimit, XrpcError } from "./xrpc"; export { Did } from "./auth"; export { Logs } from "./logs"; export { Runner } from "./runner"; export { SecretProxy, Secrets } from "./secrets"; export { Store } from "./store"; export { Webhooks } from "./webhooks"; const corsHeaders = { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, POST", "Access-Control-Allow-Headers": "Authorization, Content-Type", "Access-Control-Max-Age": "86400", }; function xrpcError(status: number, error: string, message: string): Response { return Response.json({ error, message }, { status }); } function didDocument(hostname: string): object { return { "@context": ["https://www.w3.org/ns/did/v1"], id: `did:web:${hostname}`, service: [ { id: "#tangled_spindle", type: "TangledSpindle", serviceEndpoint: `https://${hostname}`, }, ], }; } async function xrpc( method: string, request: Request, env: Env, ctx: ExecutionContext, ): Promise { const params = new URL(request.url).searchParams; switch (method) { case "org.tangled.spindle.describeSpindle": return Response.json({ did: `did:web:${env.HOSTNAME}`, version: "0.1.0", capabilities: ["tangled1.0"], }); case "org.tangled.ci.queryPipelines": await rateLimit(request, env.XRPC_LIMIT, "query:"); return Response.json( await queryPipelines( { repo: params.get("repo"), limit: Number(params.get("limit") ?? 50), cursor: params.get("cursor"), commits: params.getAll("commits"), triggers: params.getAll("triggers"), }, ctx.exports.Store.getByName("main"), ), ); case "org.tangled.ci.getPipeline": await rateLimit(request, env.XRPC_LIMIT, "query:"); return Response.json( await getPipeline( { repo: params.get("repo"), pipeline: params.get("pipeline") }, ctx.exports.Store.getByName("main"), ), ); case "org.tangled.ci.getWorkflowDefinition": await rateLimit(request, env.LOG_LIMIT); return Response.json( await getWorkflowDefinition( { repo: params.get("repo"), workflow: params.get("workflow") }, env, ), ); case "org.tangled.ci.listWorkflowDefinitions": await rateLimit(request, env.LOG_LIMIT); return Response.json( await listWorkflowDefinitions( { repo: params.get("repo"), ref: params.get("ref") }, env, ), ); case "org.tangled.ci.subscribePipelineLogs": return await subscribePipelineLogs(request, env, ctx); case "org.tangled.secret.addSecret": return await secretXrpc("addSecret", request, env, ctx.exports); case "org.tangled.secret.listSecrets": return await secretXrpc("listSecrets", request, env, ctx.exports); case "org.tangled.secret.removeSecret": return await secretXrpc("removeSecret", request, env, ctx.exports); case "org.tangled.webhook.createWebhook": case "org.tangled.webhook.updateWebhook": case "org.tangled.webhook.deleteWebhook": case "org.tangled.webhook.listWebhooks": case "org.tangled.webhook.listWebhookDeliveries": case "org.tangled.webhook.retryWebhookDelivery": return await webhookXrpc(method, request, env, ctx.exports); case "org.tangled.event.notifyEvent": return await notifyEvent(request, env, ctx.exports); case "org.tangled.ci.retryPipeline": return await retryPipeline(request, env, ctx.exports); case "org.tangled.ci.cancelPipeline": return await cancelPipeline(request, env, ctx.exports); case "org.tangled.ci.approvePipeline": return await approvePipeline(request, env, ctx.exports); default: return xrpcError(501, "MethodNotImplemented", `${method} is not implemented`); } } // The cache key leaves out the request headers, so these responses must not depend on them. const maxAge = new Map([ ["/.well-known/did.json", 3600], ["/docs", 3600], ["/xrpc/org.tangled.ci.queryPipelines", 5], ["/xrpc/org.tangled.ci.getPipeline", 5], ["/xrpc/org.tangled.ci.listWorkflowDefinitions", 5], ["/xrpc/org.tangled.ci.getWorkflowDefinition", 5], ]); export class Cached extends WorkerEntrypoint { override async fetch(request: Request): Promise { const response = await route(request, this.env, this.ctx); response.headers.set( "Cache-Control", response.ok ? `max-age=${this.ctx.props.maxAge}, must-revalidate` : "no-store", ); return response; } } async function route(request: Request, env: Env, ctx: ExecutionContext): Promise { const url = new URL(request.url); if (url.pathname === "/.well-known/did.json") { return Response.json(didDocument(env.HOSTNAME), { headers: { "Content-Type": "application/did+json" }, }); } if (url.pathname === "/docs" && request.method === "GET") { return new Response(docs, { headers: { "Content-Type": "text/markdown; charset=utf-8" }, }); } if (url.pathname === "/mcp") { if (request.method !== "POST") { return new Response(null, { status: 405, headers: { Allow: "POST" } }); } try { await rateLimit(request, env.XRPC_LIMIT, "query:"); } catch (error) { if (!(error instanceof XrpcError)) { throw error; } return xrpcError(error.status, error.error, error.message); } return await (await import("./mcp")).mcp(request, env, ctx); } if (url.pathname === "/webhooks/buildkite" && request.method === "POST") { return await buildkiteWebhook(request, env, ctx); } if (url.pathname.startsWith("/xrpc/")) { if (request.method === "OPTIONS") { return new Response(null, { status: 204, headers: corsHeaders }); } const method = url.pathname.slice("/xrpc/".length); let response: Response; try { response = await xrpc(method, request, env, ctx); } catch (error) { if (!(error instanceof XrpcError)) { throw error; } if (error.status >= 500) { console.warn("xrpc failed", { method, error: error.error, message: error.message, }); } response = xrpcError(error.status, error.error, error.message); } // A WebSocket upgrade response has immutable headers. if (response.webSocket !== null) { return response; } for (const [name, value] of Object.entries(corsHeaders)) { response.headers.set(name, value); } return response; } return new Response("Not Found", { status: 404 }); } export default { async fetch(request, env, ctx): Promise { const seconds = maxAge.get(new URL(request.url).pathname); if (request.method === "GET" && seconds !== undefined) { return await ctx.exports.Cached({ props: { maxAge: seconds } }).fetch(request); } return await route(request, env, ctx); }, } satisfies ExportedHandler;