@studio-foundation/api 0.3.0-beta.1

package/src/event-bus.ts

@@ -0,0 +1,64 @@
+export type SseEventType =
+  | 'pipeline_start'
+  | 'stage_start'
+  | 'stage_complete'
+  | 'stage_retry'
+  | 'group_start'
+  | 'group_iteration'
+  | 'group_feedback'
+  | 'group_complete'
+  | 'pipeline_complete'
+  | 'pipeline_cancelled'
+  | 'stage_context'
+  | 'tool_call_start'
+  | 'tool_call_complete'
+  | 'done';
+
+export interface BusEvent {
+  type: SseEventType;
+  data: unknown;
+}
+
+export type BusListener = (event: BusEvent) => void;
+export type GlobalBusListener = (runId: string, event: BusEvent) => void;
+
+export class RunEventBus {
+  private subs = new Map<string, Set<BusListener>>();
+  private globalListeners = new Set<GlobalBusListener>();
+
+  subscribe(runId: string, listener: BusListener): () => void {
+    if (!this.subs.has(runId)) {
+      this.subs.set(runId, new Set());
+    }
+    this.subs.get(runId)!.add(listener);
+    return () => {
+      this.subs.get(runId)?.delete(listener);
+    };
+  }
+
+  // Global subscription — receives all events across all runs
+  subscribeAll(listener: GlobalBusListener): () => void {
+    this.globalListeners.add(listener);
+    return () => {
+      this.globalListeners.delete(listener);
+    };
+  }
+
+  emit(runId: string, type: SseEventType, data: unknown): void {
+    const event: BusEvent = { type, data };
+    const listeners = this.subs.get(runId);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(event);
+      }
+    }
+    for (const listener of this.globalListeners) {
+      listener(runId, event);
+    }
+  }
+
+  close(runId: string): void {
+    this.emit(runId, 'done', {});
+    this.subs.delete(runId);
+  }
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Standalone entrypoint for @studio/api
+// PM2: pm2 start node_modules/.bin/studio-api --env STUDIO_CWD=/path/to/project
+// systemd: ExecStart=/usr/bin/node /path/to/api/dist/index.js
+
+import { bootstrap } from './bootstrap.js';
+import { buildServer } from './server.js';
+
+const DEFAULT_PORT = 3700;
+
+async function main() {
+  const cwd = process.env['STUDIO_CWD'] ?? process.cwd();
+
+  let result: Awaited<ReturnType<typeof bootstrap>>;
+  try {
+    result = await bootstrap(cwd);
+  } catch (err) {
+    console.error('Bootstrap failed:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  const { store, launcher, configsDir, projectName, apiConfig, cleanup, studioVersion, maskedConfig, webhookStore, integrationStore, integrationRuntime, userStore, plans } = result;
+  const port = apiConfig.port ?? DEFAULT_PORT;
+
+  let hasUsers = false;
+  try {
+    // listUsers() is sync on UserStore and async on PgUserStore; await handles both
+    const users = await userStore.listUsers();
+    hasUsers = users.length > 0;
+  } catch {
+    // DB unavailable at startup — default to open/dev mode
+  }
+
+  const server = buildServer({ store, launcher, configsDir, projectName, apiConfig, studioVersion, maskedConfig, webhookStore, integrationStore, integrationRuntime, userStore, plans, hasUsers });
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    await server.close();
+    await cleanup();
+    process.exit(0);
+  };
+  process.on('SIGTERM', () => void shutdown());
+  process.on('SIGINT', () => void shutdown());
+
+  try {
+    await server.listen({ port, host: '0.0.0.0' });
+    console.log(`Studio API listening on port ${port}`);
+    if (!apiConfig.key) {
+      console.log('Warning: no api.key configured — running without auth');
+    }
+  } catch (err) {
+    console.error('Failed to start server:', err);
+    await cleanup();
+    process.exit(1);
+  }
+}
+
+void main();

package/src/integration-runtime.ts

@@ -0,0 +1,180 @@
+// api/src/integration-runtime.ts
+import type { FastifyInstance } from 'fastify';
+import type { IntegrationPluginDef } from '@studio-foundation/contracts';
+import type { IntegrationStore } from './integration-store.js';
+import type { RunLauncher } from './launcher.js';
+import type { RunEventBus } from './event-bus.js';
+import type { ApiConfig } from './server.js';
+import { WEBHOOK_HANDLERS, FAILURE_HANDLERS } from './integrations/registry.js';
+import type { FailureHandlerContext } from './integrations/types.js';
+import type { GroupFeedbackEvent } from '@studio-foundation/engine';
+
+export interface IntegrationRuntimeDeps {
+  integrations: IntegrationPluginDef[];
+  store: IntegrationStore;
+  launcher: RunLauncher;
+  configsDir: string;
+  projectsDir?: string;
+  apiConfig: ApiConfig;
+  integrationConfigs: Record<string, Record<string, unknown>>;
+}
+
+export class IntegrationRuntime {
+  constructor(private deps: IntegrationRuntimeDeps) {}
+
+  setupEventBus(bus: RunEventBus): void {
+    bus.subscribeAll((runId, event) => {
+      if (event.type !== 'pipeline_complete') return;
+
+      const data = event.data as {
+        status: string;
+        duration_ms: number;
+        meta?: Record<string, unknown>;
+        last_group_feedback?: GroupFeedbackEvent;
+      };
+
+      if (data.status === 'success') return;
+
+      for (const integration of this.deps.integrations) {
+        if (!integration.on_failure?.handler) continue;
+        const handler = FAILURE_HANDLERS[integration.on_failure.handler];
+        if (!handler) continue;
+
+        const ctx: FailureHandlerContext = {
+          runId,
+          durationMs: data.duration_ms,
+          status: data.status,
+          meta: data.meta ?? {},
+          lastGroupFeedback: data.last_group_feedback,
+          integration,
+          integrationConfig: this.deps.integrationConfigs[integration.name] ?? {},
+        };
+
+        void handler.handleFailure(ctx);
+      }
+    });
+  }
+
+  registerRoutes(fastify: FastifyInstance, prefix: string): void {
+    for (const integration of this.deps.integrations) {
+      if (!integration.webhook?.handler) continue;
+      const webhookHandler = WEBHOOK_HANDLERS[integration.webhook.handler];
+      if (!webhookHandler) continue;
+
+      const name = integration.name;
+      const { store, launcher, configsDir, projectsDir, apiConfig, integrationConfigs } = this.deps;
+      const integrationConfig = integrationConfigs[name] ?? {};
+      const errorSchema = { type: 'object', properties: { error: { type: 'string' } } };
+
+      void fastify.register(async (scope) => {
+        scope.addContentTypeParser(
+          'application/json',
+          { parseAs: 'buffer' },
+          (_req, body, done) => done(null, body),
+        );
+
+        // GET /api/integrations/{name}
+        scope.get(`${prefix}/integrations/${name}`, {
+          schema: {
+            tags: ['integrations'],
+            summary: `Get ${name} integration config and trigger log`,
+            response: {
+              200: {
+                type: 'object',
+                properties: {
+                  webhook_url: { type: 'string' },
+                  pipeline: { type: ['string', 'null'] },
+                  active: { type: 'boolean' },
+                  triggers: { type: 'array' },
+                },
+              },
+            },
+          },
+        }, async (request, reply) => {
+          const config = store.getConfig(name);
+          const triggers = store.listTriggers(name, 50);
+          const baseUrl = process.env['STUDIO_BASE_URL'] ?? `${request.protocol}://${request.hostname}`;
+          return reply.status(200).send({
+            webhook_url: `${baseUrl}/api/integrations/${name}/webhook`,
+            pipeline: config.pipeline ?? null,
+            active: config.active,
+            triggers,
+          });
+        });
+
+        // PATCH /api/integrations/{name}
+        scope.patch(`${prefix}/integrations/${name}`, {
+          schema: {
+            tags: ['integrations'],
+            summary: `Update ${name} integration config`,
+            body: {
+              type: 'object',
+              properties: {
+                pipeline: { type: 'string' },
+                active: { type: 'boolean' },
+              },
+            },
+            response: {
+              200: {
+                type: 'object',
+                properties: {
+                  webhook_url: { type: 'string' },
+                  pipeline: { type: ['string', 'null'] },
+                  active: { type: 'boolean' },
+                },
+              },
+              400: errorSchema,
+            },
+          },
+        }, async (request, reply) => {
+          let data: { pipeline?: string; active?: boolean };
+          try {
+            data = JSON.parse((request.body as Buffer).toString('utf-8')) as typeof data;
+          } catch {
+            return reply.status(400).send({ error: 'Invalid JSON' });
+          }
+          store.patchConfig(name, data);
+          const updated = store.getConfig(name);
+          const baseUrl = process.env['STUDIO_BASE_URL'] ?? `${request.protocol}://${request.hostname}`;
+          return reply.status(200).send({
+            webhook_url: `${baseUrl}/api/integrations/${name}/webhook`,
+            pipeline: updated.pipeline ?? null,
+            active: updated.active,
+          });
+        });
+
+        // POST /api/integrations/{name}/webhook
+        scope.post(`${prefix}/integrations/${name}/webhook`, {
+          schema: {
+            tags: ['integrations'],
+            summary: `Receive ${name} webhook event`,
+            response: {
+              202: {
+                type: 'object',
+                properties: { run_id: { type: 'string' }, stream_url: { type: 'string' } },
+              },
+              200: {
+                type: 'object',
+                properties: { ignored: { type: 'boolean' }, reason: { type: 'string' } },
+              },
+              400: errorSchema,
+              401: errorSchema,
+            },
+          },
+        }, async (request, reply) => {
+          return webhookHandler.handle({
+            rawBody: request.body as Buffer,
+            headers: request.headers,
+            integration,
+            store,
+            launcher,
+            configsDir,
+            projectsDir,
+            apiConfig,
+            integrationConfig,
+          }, reply);
+        });
+      });
+    }
+  }
+}

package/src/integration-store.ts

@@ -0,0 +1,125 @@
+// IntegrationStore — generic SQLite persistence for integration configs and trigger logs
+// Partitioned by integration_name — supports any integration (linear, slack, github, etc.)
+// Uses the same DB file as the run store (.studio/runs/runs.db)
+
+import { createRequire } from 'node:module';
+
+export interface IntegrationConfig {
+  pipeline?: string;
+  active: boolean;
+}
+
+export interface IntegrationTriggerRecord {
+  id: string;
+  integration_name: string;
+  received_at: string;
+  external_id?: string;
+  external_label?: string;
+  external_url?: string;
+  pipeline: string;
+  run_id?: string;
+  status: 'success' | 'failed';
+}
+
+export class IntegrationStore {
+  private db: import('better-sqlite3').Database;
+
+  constructor(dbPath: string) {
+    const _require = createRequire(import.meta.url);
+    const Database = _require('better-sqlite3') as new (path: string) => import('better-sqlite3').Database;
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.initSchema();
+  }
+
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS integration_config (
+        integration_name TEXT NOT NULL,
+        pipeline TEXT,
+        active INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (integration_name)
+      );
+
+      CREATE TABLE IF NOT EXISTS integration_triggers (
+        id TEXT PRIMARY KEY,
+        integration_name TEXT NOT NULL,
+        received_at TEXT NOT NULL,
+        external_id TEXT,
+        external_label TEXT,
+        external_url TEXT,
+        pipeline TEXT NOT NULL,
+        run_id TEXT,
+        status TEXT NOT NULL
+      );
+    `);
+  }
+
+  getConfig(integrationName: string): IntegrationConfig {
+    const row = this.db.prepare(
+      'SELECT pipeline, active FROM integration_config WHERE integration_name = ?'
+    ).get(integrationName) as { pipeline: string | null; active: number } | undefined;
+
+    if (!row) return { active: false };
+    return {
+      ...(row.pipeline != null ? { pipeline: row.pipeline } : {}),
+      active: row.active === 1,
+    };
+  }
+
+  patchConfig(integrationName: string, data: Partial<IntegrationConfig>): void {
+    const current = this.getConfig(integrationName);
+    const pipeline = 'pipeline' in data ? (data.pipeline ?? null) : (current.pipeline ?? null);
+    const active = 'active' in data ? (data.active ? 1 : 0) : (current.active ? 1 : 0);
+    this.db.prepare(`
+      INSERT INTO integration_config (integration_name, pipeline, active) VALUES (?, ?, ?)
+      ON CONFLICT(integration_name) DO UPDATE SET pipeline = excluded.pipeline, active = excluded.active
+    `).run(integrationName, pipeline, active);
+  }
+
+  insertTrigger(trigger: IntegrationTriggerRecord): void {
+    this.db.prepare(`
+      INSERT INTO integration_triggers
+        (id, integration_name, received_at, external_id, external_label, external_url, pipeline, run_id, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      trigger.id,
+      trigger.integration_name,
+      trigger.received_at,
+      trigger.external_id ?? null,
+      trigger.external_label ?? null,
+      trigger.external_url ?? null,
+      trigger.pipeline,
+      trigger.run_id ?? null,
+      trigger.status,
+    );
+  }
+
+  listTriggers(integrationName: string, limit = 50): IntegrationTriggerRecord[] {
+    type Row = {
+      id: string; integration_name: string; received_at: string;
+      external_id: string | null; external_label: string | null; external_url: string | null;
+      pipeline: string; run_id: string | null; status: string;
+    };
+    const rows = this.db.prepare(
+      `SELECT id, integration_name, received_at, external_id, external_label, external_url, pipeline, run_id, status
+       FROM integration_triggers WHERE integration_name = ? ORDER BY received_at DESC LIMIT ?`
+    ).all(integrationName, limit) as Row[];
+
+    return rows.map(row => ({
+      id: row.id,
+      integration_name: row.integration_name,
+      received_at: row.received_at,
+      ...(row.external_id != null ? { external_id: row.external_id } : {}),
+      ...(row.external_label != null ? { external_label: row.external_label } : {}),
+      ...(row.external_url != null ? { external_url: row.external_url } : {}),
+      pipeline: row.pipeline,
+      ...(row.run_id != null ? { run_id: row.run_id } : {}),
+      status: row.status as 'success' | 'failed',
+    }));
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/integrations/linear/failure-handler.ts

@@ -0,0 +1,93 @@
+// api/src/integrations/linear/failure-handler.ts
+import type { FailureHandler, FailureHandlerContext } from '../types.js';
+
+const LINEAR_GRAPHQL_URL = 'https://api.linear.app/graphql';
+
+async function gql(query: string, variables: Record<string, unknown>, apiKey: string): Promise<Record<string, unknown>> {
+  const res = await fetch(LINEAR_GRAPHQL_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: apiKey },
+    body: JSON.stringify({ query, variables }),
+  });
+  if (!res.ok) throw new Error(`Linear GraphQL HTTP error: ${res.status} ${res.statusText}`);
+  return res.json() as Promise<Record<string, unknown>>;
+}
+
+function buildFailureComment(ctx: FailureHandlerContext): string {
+  const iterations = ctx.lastGroupFeedback?.iteration;
+  const iterLabel = iterations != null ? ` après ${iterations} itérations QA` : '';
+  const rejectionReason = ctx.lastGroupFeedback?.rejection_reason;
+  const rejectionDetails = ctx.lastGroupFeedback?.rejection_details;
+  const lines: string[] = [];
+  lines.push(`❌ **Code Builder échoué** —${iterLabel ? ` QA a rejeté${iterLabel}` : ' pipeline échoué'}`);
+  lines.push('');
+  if (rejectionReason) {
+    lines.push('**Dernière raison de rejet :**');
+    if (rejectionDetails && rejectionDetails.length > 0) {
+      for (const detail of rejectionDetails) lines.push(`- ${detail}`);
+    } else {
+      lines.push(`- ${rejectionReason}`);
+    }
+    lines.push('');
+  }
+  lines.push('**Action requise :** réviser le brief ou augmenter max_iterations');
+  lines.push('');
+  lines.push(`**Run ID :** ${ctx.runId}`);
+  return lines.join('\n');
+}
+
+export class LinearFailureHandler implements FailureHandler {
+  async handleFailure(ctx: FailureHandlerContext): Promise<void> {
+    const issueId = typeof ctx.meta['linear_issue_id'] === 'string' ? ctx.meta['linear_issue_id'] : undefined;
+    if (!issueId) return;
+
+    const apiKey = (ctx.integrationConfig['LINEAR_API_KEY'] as string | undefined)
+      ?? process.env['LINEAR_API_KEY'];
+    if (!apiKey) {
+      console.warn('[linear-failure-handler] LINEAR_API_KEY not set — skipping failure notification');
+      return;
+    }
+
+    const comment = buildFailureComment(ctx);
+    try {
+      await gql(
+        `mutation CreateComment($issueId: String!, $body: String!) {
+          commentCreate(input: { issueId: $issueId, body: $body }) { success }
+        }`,
+        { issueId, body: comment },
+        apiKey,
+      );
+
+      const statesResult = await gql(
+        `query GetWorkflowStates($issueId: String!) {
+          issue(id: $issueId) { team { states { nodes { id name } } } }
+        }`,
+        { issueId },
+        apiKey,
+      );
+
+      type StateNode = { id: string; name: string };
+      const nodes = (
+        (statesResult as { data?: { issue?: { team?: { states?: { nodes?: StateNode[] } } } } })
+          .data?.issue?.team?.states?.nodes
+      ) ?? [];
+      const backlogState = nodes.find((s: StateNode) => s.name === 'Backlog');
+
+      if (backlogState) {
+        await gql(
+          `mutation UpdateIssue($id: String!, $stateId: String!) {
+            issueUpdate(id: $id, input: { stateId: $stateId }) { success }
+          }`,
+          { id: issueId, stateId: backlogState.id },
+          apiKey,
+        );
+      } else {
+        console.warn(`[linear-failure-handler] "Backlog" state not found for issue ${issueId} — status not updated`);
+      }
+
+      console.log(`[linear-failure-handler] Failure notification posted for issue ${issueId}`);
+    } catch (err) {
+      console.error('[linear-failure-handler] Failed to notify Linear:', err);
+    }
+  }
+}

package/src/integrations/linear/webhook-handler.ts

@@ -0,0 +1,156 @@
+// LinearWebhookHandler — plugin class implementing WebhookHandler
+// Extracted from routes/linear-webhook.ts POST /integrations/linear/webhook
+// Receives all deps via WebhookHandlerContext instead of Fastify plugin closure.
+
+import { createHmac, timingSafeEqual, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import type { FastifyReply } from 'fastify';
+import type { WebhookHandler, WebhookHandlerContext } from '../types.js';
+import { loadPipelineByName } from '@studio-foundation/engine';
+import { resolveRepoPath } from '../../utils/repo-resolver.js';
+
+interface LinearIssuePayload {
+  type?: string;
+  action?: string;
+  data?: {
+    id?: string;
+    identifier?: string;
+    title?: string;
+    description?: string;
+    state?: { name?: string };
+  };
+}
+
+function verifyHmac(rawBody: Buffer, signature: string, secret: string): boolean {
+  const computed = createHmac('sha256', secret).update(rawBody).digest('hex');
+  try {
+    const a = Buffer.from(computed, 'hex');
+    const b = Buffer.from(signature, 'hex');
+    if (a.length !== b.length) return false;
+    return timingSafeEqual(a, b);
+  } catch {
+    return false;
+  }
+}
+
+export class LinearWebhookHandler implements WebhookHandler {
+  async handle(ctx: WebhookHandlerContext, reply: FastifyReply): Promise<unknown> {
+    const { rawBody, headers, integration, store, launcher, configsDir, projectsDir, integrationConfig } = ctx;
+
+    // HMAC verification — only when hmac config is present in the integration def
+    const hmacConfig = integration.webhook?.hmac;
+    if (hmacConfig) {
+      const secret = integrationConfig[hmacConfig.secret_env] as string | undefined;
+      if (secret) {
+        const sig = headers[hmacConfig.header];
+        if (typeof sig !== 'string') {
+          return reply.status(401).send({ error: `Missing ${hmacConfig.header} header` });
+        }
+        if (!verifyHmac(rawBody, sig, secret)) {
+          return reply.status(401).send({ error: 'Invalid signature' });
+        }
+      }
+    }
+
+    let payload: LinearIssuePayload;
+    try {
+      payload = JSON.parse(rawBody.toString('utf-8')) as LinearIssuePayload;
+    } catch {
+      return reply.status(400).send({ error: 'Invalid JSON' });
+    }
+
+    // Only handle Issue update events
+    if (payload.type !== 'Issue' || payload.action !== 'update') {
+      return reply.status(200).send({ ignored: true, reason: 'not an issue update' });
+    }
+
+    const issue = payload.data ?? {};
+
+    // Only trigger on transitions to "In Progress"
+    if (issue.state?.name !== 'In Progress') {
+      return reply.status(200).send({ ignored: true, reason: `state is "${issue.state?.name ?? 'unknown'}"` });
+    }
+
+    // Check integration is active
+    const config = store.getConfig(integration.name);
+    if (!config.active) {
+      return reply.status(200).send({ ignored: true, reason: 'integration is inactive' });
+    }
+
+    const pipeline = config.pipeline ?? 'feature-builder';
+    const issueUrl = `https://linear.app/studioag/issue/${issue.identifier}`;
+
+    // Resolve repo path from pipeline YAML — mirrors CLI behaviour.
+    // If the pipeline file can't be loaded, fall back gracefully —
+    // launcher.launch() will surface the proper "pipeline not found" error afterwards.
+    let pipelineRepoUrl: string | undefined;
+    let pipelineRepoBranch: string | undefined;
+    try {
+      const pipelineDef = await loadPipelineByName(pipeline, join(configsDir, 'pipelines'));
+      pipelineRepoUrl = pipelineDef.repo?.url;
+      pipelineRepoBranch = pipelineDef.repo?.branch;
+    } catch {
+      // Pipeline not found or unparseable — launcher.launch() will handle the error
+    }
+
+    let repoPath: string;
+    try {
+      repoPath = await resolveRepoPath({
+        repoUrl: pipelineRepoUrl,
+        rawProjectsDir: projectsDir,
+        pipelineName: pipeline,
+        branch: pipelineRepoBranch,
+      });
+    } catch (err) {
+      return reply.status(400).send({ error: err instanceof Error ? err.message : String(err) });
+    }
+
+    // Construct structured input for the configured pipeline
+    const input: Record<string, unknown> = {
+      brief_summary: [issue.identifier, issue.title].filter(Boolean).join(' — '),
+      description: issue.description ?? '',
+      acceptance_criteria: [],
+    };
+
+    const meta: Record<string, unknown> = {
+      linear_issue_id: issue.id,
+      linear_issue_identifier: issue.identifier,
+      linear_issue_url: issueUrl,
+    };
+
+    const runId = randomUUID();
+    const triggerId = randomUUID();
+    const receivedAt = new Date().toISOString();
+
+    try {
+      await launcher.launch({ runId, pipeline, input, configsDir, repoPath, meta });
+
+      store.insertTrigger({
+        id: triggerId,
+        integration_name: integration.name,
+        received_at: receivedAt,
+        external_id: issue.id,
+        external_label: [issue.identifier, issue.title].filter(Boolean).join(' — '),
+        external_url: issueUrl,
+        pipeline,
+        run_id: runId,
+        status: 'success',
+      });
+    } catch (err) {
+      store.insertTrigger({
+        id: triggerId,
+        integration_name: integration.name,
+        received_at: receivedAt,
+        external_id: issue.id,
+        external_label: [issue.identifier, issue.title].filter(Boolean).join(' — '),
+        external_url: issueUrl,
+        pipeline,
+        run_id: runId,
+        status: 'failed',
+      });
+      throw err;
+    }
+
+    return reply.status(202).send({ run_id: runId, stream_url: `/api/runs/${runId}/stream` });
+  }
+}

package/src/integrations/registry.ts

@@ -0,0 +1,12 @@
+// api/src/integrations/registry.ts
+import type { WebhookHandler, FailureHandler } from './types.js';
+import { LinearWebhookHandler } from './linear/webhook-handler.js';
+import { LinearFailureHandler } from './linear/failure-handler.js';
+
+export const WEBHOOK_HANDLERS: Record<string, WebhookHandler> = {
+  'linear-webhook': new LinearWebhookHandler(),
+};
+
+export const FAILURE_HANDLERS: Record<string, FailureHandler> = {
+  'linear-failure': new LinearFailureHandler(),
+};