@supaku/agentfactory-nextjs 0.3.0

package/dist/src/webhook/handlers/session-created.js

@@ -0,0 +1,229 @@
+/**
+ * Handle agent session 'create' events — new session initiated.
+ */
+import { NextResponse } from 'next/server';
+import { TERMINAL_STATUSES, validateWorkTypeForStatus, WORK_TYPE_ALLOWED_STATUSES, STATUS_WORK_TYPE_MAP, getValidWorkTypesForStatus, } from '@supaku/agentfactory-linear';
+import { generateIdempotencyKey, isWebhookProcessed, storeSessionState, getSessionState, updateSessionStatus, dispatchWork, } from '@supaku/agentfactory-server';
+import { emitActivity, determineWorkType, getAppUrl, getPriority, WORK_TYPE_MESSAGES, } from '../utils.js';
+export async function handleSessionCreated(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    log.debug('AgentSessionEvent payload structure', {
+        payloadKeys: Object.keys(rawPayload),
+        agentSessionKeys: agentSession ? Object.keys(agentSession) : [],
+        hasAgentSession: !!agentSession,
+    });
+    if (!agentSession) {
+        log.error('AgentSessionEvent missing agentSession field', {
+            payloadKeys: Object.keys(rawPayload),
+        });
+        return NextResponse.json({ error: 'Missing agentSession in webhook payload', success: false }, { status: 400 });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const webhookId = rawPayload.webhookId;
+    const agentId = agentSession.agentId;
+    if (!sessionId || !issueId) {
+        log.error('Missing sessionId or issueId in webhook payload', {
+            sessionId,
+            issueId,
+            agentSessionKeys: Object.keys(agentSession),
+        });
+        return NextResponse.json({ error: 'Invalid payload structure', success: false }, { status: 400 });
+    }
+    const sessionLog = log.child({ sessionId, issueId });
+    const promptContext = rawPayload.promptContext;
+    const user = rawPayload.user;
+    const comment = rawPayload.comment;
+    const isMention = !!comment;
+    const initiationType = isMention ? 'mention' : 'delegation';
+    sessionLog.info('Agent session created', {
+        initiationType,
+        isMention,
+        hasPromptContext: !!promptContext,
+        promptContextLength: promptContext?.length,
+        userName: user?.name,
+    });
+    // Idempotency check
+    const idempotencyKey = generateIdempotencyKey(webhookId, sessionId);
+    if (await isWebhookProcessed(idempotencyKey)) {
+        sessionLog.info('Duplicate webhook ignored', { idempotencyKey });
+        return NextResponse.json({ success: true, skipped: true, reason: 'duplicate_webhook' });
+    }
+    const existingSession = await getSessionState(sessionId);
+    if (existingSession) {
+        sessionLog.info('Session already exists', { status: existingSession.status });
+        return NextResponse.json({ success: true, skipped: true, reason: 'session_already_exists' });
+    }
+    const issueIdentifier = issue?.identifier || issueId.slice(0, 8);
+    // Determine work type
+    let workType = 'development';
+    let currentStatus;
+    let workTypeSource = 'status';
+    // Fetch current issue status
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const issueDetails = await linearClient.getIssue(issueId);
+        const currentState = await issueDetails.state;
+        currentStatus = currentState?.name;
+        sessionLog.debug('Fetched current issue status', { currentStatus });
+    }
+    catch (err) {
+        sessionLog.warn('Failed to fetch issue status', { error: err });
+    }
+    // Phase 1: Mention-based routing
+    if (isMention && promptContext && config.detectWorkTypeFromPrompt) {
+        // For mentions: unconstrained detection (pass all work types)
+        const allWorkTypes = [
+            'coordination', 'backlog-creation', 'research', 'qa', 'inflight',
+            'acceptance', 'refinement', 'development', 'qa-coordination', 'acceptance-coordination',
+        ];
+        const mentionWorkType = config.detectWorkTypeFromPrompt(promptContext, allWorkTypes);
+        if (mentionWorkType) {
+            workType = mentionWorkType;
+            workTypeSource = 'mention';
+            sessionLog.info('Detected work type from mention prompt', {
+                workType,
+                currentStatus,
+                promptPreview: promptContext.substring(0, 50),
+            });
+        }
+    }
+    // For non-mentions or when mention detection failed: constrained detection
+    if (workTypeSource === 'status' && promptContext && currentStatus && config.detectWorkTypeFromPrompt) {
+        const validWorkTypes = getValidWorkTypesForStatus(currentStatus);
+        const constrainedWorkType = config.detectWorkTypeFromPrompt(promptContext, validWorkTypes);
+        if (constrainedWorkType) {
+            workType = constrainedWorkType;
+            workTypeSource = 'mention';
+            sessionLog.info('Detected work type from promptContext (constrained)', {
+                workType,
+                currentStatus,
+                validWorkTypes,
+            });
+        }
+    }
+    // Phase 2: Fall back to status-based routing
+    if (workTypeSource === 'status') {
+        workType = determineWorkType(currentStatus);
+        sessionLog.info('Detected work type from issue status', {
+            currentStatus,
+            workType,
+        });
+    }
+    // Phase 2.5: Auto-detect parent issues for coordination
+    if (workType === 'development' && workTypeSource === 'status') {
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            const isParent = await linearClient.isParentIssue(issueId);
+            if (isParent) {
+                workType = 'coordination';
+                sessionLog.info('Parent issue detected, switching to coordination work type', {
+                    issueIdentifier,
+                });
+            }
+        }
+        catch (err) {
+            sessionLog.warn('Failed to check if issue is parent', { error: err });
+        }
+    }
+    // Check terminal state
+    if (currentStatus && TERMINAL_STATUSES.includes(currentStatus)) {
+        sessionLog.info('Issue in terminal state, acknowledging mention', { currentStatus });
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            await emitActivity(linearClient, sessionId, 'response', `This issue is in **${currentStatus}** status and has been completed. No further agent work is needed.\n\n` +
+                `If you need additional help, please create a new issue or reopen this one by moving it back to an active status.`);
+        }
+        catch (err) {
+            sessionLog.error('Failed to emit terminal state response', { error: err });
+        }
+        return NextResponse.json({ success: true, skipped: true, reason: 'terminal_state', currentStatus });
+    }
+    // Validate work type for status
+    if (currentStatus) {
+        const validation = validateWorkTypeForStatus(workType, currentStatus);
+        if (!validation.valid) {
+            sessionLog.warn('Work type validation failed', { workType, currentStatus, error: validation.error });
+            try {
+                const linearClient = await config.linearClient.getClient(payload.organizationId);
+                const allowedStatuses = WORK_TYPE_ALLOWED_STATUSES[workType];
+                const expectedWorkType = STATUS_WORK_TYPE_MAP[currentStatus];
+                await emitActivity(linearClient, sessionId, 'error', `Cannot perform ${workType} work on this issue.\n\n` +
+                    `**Current status:** ${currentStatus}\n` +
+                    `**${workType} requires status:** ${allowedStatuses.join(' or ')}\n\n` +
+                    (expectedWorkType
+                        ? `For issues in ${currentStatus} status, use ${expectedWorkType} commands instead.`
+                        : `This issue's status (${currentStatus}) is not handled by the agent.`));
+            }
+            catch (err) {
+                sessionLog.error('Failed to emit validation error activity', { error: err });
+            }
+            return NextResponse.json({
+                success: false,
+                error: 'work_type_invalid_for_status',
+                message: validation.error,
+            });
+        }
+    }
+    const priority = getPriority(config, workType);
+    await storeSessionState(sessionId, {
+        issueId,
+        issueIdentifier,
+        claudeSessionId: null,
+        worktreePath: '',
+        status: 'pending',
+        queuedAt: Date.now(),
+        promptContext: promptContext,
+        priority,
+        organizationId: payload.organizationId,
+        workType,
+        agentId,
+    });
+    // Queue work
+    const work = {
+        sessionId,
+        issueId,
+        issueIdentifier,
+        priority,
+        queuedAt: Date.now(),
+        workType,
+        prompt: config.generatePrompt(issueIdentifier, workType, promptContext),
+    };
+    const result = await dispatchWork(work);
+    if (result.dispatched || result.parked) {
+        sessionLog.info('Work dispatched', {
+            sessionId,
+            issueIdentifier,
+            workType,
+            dispatched: result.dispatched,
+            parked: result.parked,
+            replaced: result.replaced,
+        });
+    }
+    else {
+        sessionLog.error('Failed to dispatch work');
+        await updateSessionStatus(sessionId, 'failed');
+    }
+    // Update session with externalUrl and acknowledge
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const appUrl = getAppUrl(config);
+        await linearClient.updateAgentSession({
+            sessionId,
+            externalUrls: [
+                {
+                    label: 'Agent Dashboard',
+                    url: `${appUrl}/sessions/${sessionId}`,
+                },
+            ],
+        });
+        const activityText = WORK_TYPE_MESSAGES[workType];
+        await emitActivity(linearClient, sessionId, 'thought', activityText);
+        sessionLog.debug('Session updated and activity emitted');
+    }
+    catch (err) {
+        sessionLog.error('Failed to update session or create comment', { error: err });
+    }
+    return null; // Continue processing
+}

package/dist/src/webhook/handlers/session-prompted.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle agent session 'prompted' events — follow-up messages or stop/continue signals.
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@supaku/agentfactory-linear';
+import type { WebhookConfig } from '../../types.js';
+import type { createLogger } from '@supaku/agentfactory-server';
+export declare function handleSessionPrompted(config: WebhookConfig, payload: LinearWebhookPayload, rawPayload: Record<string, unknown>, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=session-prompted.d.ts.map

package/dist/src/webhook/handlers/session-prompted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-prompted.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/session-prompted.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,6BAA6B,CAAA;AAatF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAE/D,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAkP9B"}

package/dist/src/webhook/handlers/session-prompted.js

@@ -0,0 +1,197 @@
+/**
+ * Handle agent session 'prompted' events — follow-up messages or stop/continue signals.
+ */
+import { NextResponse } from 'next/server';
+import { getSessionState, updateSessionStatus, storeSessionState, releaseClaim, removeWorkerSession, dispatchWork, storePendingPrompt, generateIdempotencyKey, isWebhookProcessed, } from '@supaku/agentfactory-server';
+import { handleStopSignal, emitActivity } from '../utils.js';
+export async function handleSessionPrompted(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    if (!agentSession) {
+        log.warn('AgentSessionEvent prompted missing agentSession field');
+        return NextResponse.json({ success: true, skipped: true, reason: 'missing_agent_session' });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const promptText = rawPayload.promptContext || '';
+    const webhookId = rawPayload.webhookId;
+    const user = rawPayload.user;
+    const agentActivity = rawPayload.agentActivity;
+    const comment = rawPayload.comment;
+    const commentBody = comment?.body || '';
+    const promptLog = log.child({ sessionId, issueId });
+    // Check for stop/continue signals
+    const activitySignal = agentActivity?.signal;
+    const isStopSignal = activitySignal === 'stop';
+    const isContinueSignal = activitySignal === 'continue';
+    promptLog.info('Agent session prompted', {
+        hasPromptContext: !!promptText,
+        promptContextLength: promptText?.length,
+        userName: user?.name,
+        hasAgentActivity: !!agentActivity,
+        activitySignal,
+        isStopSignal,
+        isContinueSignal,
+        hasComment: !!comment,
+        commentBodyLength: commentBody?.length,
+    });
+    // Handle stop signal
+    if (isStopSignal) {
+        promptLog.info('Stop signal received via prompted webhook');
+        await handleStopSignal(config, sessionId, issueId, payload.organizationId);
+        return NextResponse.json({ success: true, action: 'stopped', sessionId });
+    }
+    // Handle continue signal
+    if (isContinueSignal) {
+        promptLog.info('Continue signal received via prompted webhook');
+        const existingSession = await getSessionState(sessionId);
+        const workType = existingSession?.workType || 'inflight';
+        let resumePrompt = promptText || commentBody || '';
+        const issueIdentifier = existingSession?.issueIdentifier ||
+            issue?.identifier ||
+            issueId.slice(0, 8);
+        promptLog.info('Session state for continue', {
+            hasExistingSession: !!existingSession,
+            sessionStatus: existingSession?.status,
+            workType,
+        });
+        if (!resumePrompt.trim()) {
+            resumePrompt = config.generatePrompt(issueIdentifier, workType);
+        }
+        // Reset session status if in terminal state
+        if (existingSession && ['completed', 'failed', 'stopped'].includes(existingSession.status)) {
+            await releaseClaim(sessionId);
+            if (existingSession.workerId) {
+                await removeWorkerSession(existingSession.workerId, sessionId);
+            }
+            await updateSessionStatus(sessionId, 'pending');
+        }
+        // Update organizationId if missing
+        if (existingSession && !existingSession.organizationId && payload.organizationId) {
+            await storeSessionState(sessionId, {
+                ...existingSession,
+                organizationId: payload.organizationId,
+                status: 'pending',
+            });
+        }
+        // Queue work to resume
+        const work = {
+            sessionId,
+            issueId,
+            issueIdentifier,
+            priority: 2,
+            queuedAt: Date.now(),
+            prompt: resumePrompt,
+            claudeSessionId: existingSession?.claudeSessionId || undefined,
+            workType,
+        };
+        await dispatchWork(work);
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            await emitActivity(linearClient, sessionId, 'thought', 'Session resume requested. Waiting for an available worker...');
+        }
+        catch (err) {
+            promptLog.error('Failed to emit continue acknowledgment activity', { error: err });
+        }
+        return NextResponse.json({ success: true, action: 'continue_queued', sessionId });
+    }
+    // Generate idempotency key for prompted events
+    const idempotencyKey = generateIdempotencyKey(webhookId, `${sessionId}:prompt:${payload.createdAt}`);
+    if (await isWebhookProcessed(idempotencyKey)) {
+        promptLog.info('Duplicate prompted webhook ignored', { idempotencyKey });
+        return NextResponse.json({ success: true, skipped: true, reason: 'duplicate_prompt' });
+    }
+    const existingSession = await getSessionState(sessionId);
+    const issueIdentifier = existingSession?.issueIdentifier ||
+        issue?.identifier ||
+        issueId.slice(0, 8);
+    // Determine effective prompt with cascading fallbacks
+    let effectivePrompt = promptText.trim();
+    if (!effectivePrompt && commentBody.trim()) {
+        effectivePrompt = commentBody.trim();
+        promptLog.info('Using comment body as prompt fallback');
+    }
+    if (!effectivePrompt) {
+        if (existingSession) {
+            effectivePrompt = config.generatePrompt(issueIdentifier, existingSession.workType || 'inflight');
+            promptLog.info('Generated continue prompt for empty prompt');
+        }
+        else {
+            promptLog.warn('Empty prompt with no existing session, skipping');
+            return NextResponse.json({ success: true, skipped: true, reason: 'empty_prompt_no_session' });
+        }
+    }
+    // If session is running, store as pending prompt
+    if (existingSession?.status === 'running' || existingSession?.status === 'claimed') {
+        const userInfo = user ? {
+            id: user.id,
+            name: user.name,
+        } : undefined;
+        const pendingPrompt = await storePendingPrompt(sessionId, issueId, effectivePrompt, userInfo);
+        if (pendingPrompt) {
+            promptLog.info('Pending prompt stored for running session', {
+                promptId: pendingPrompt.id,
+                sessionId,
+                issueIdentifier,
+                workerId: existingSession.workerId,
+            });
+        }
+        else {
+            promptLog.error('Failed to store pending prompt');
+        }
+    }
+    else {
+        // Session not running — queue as work
+        promptLog.info('Queuing follow-up for non-running session', {
+            sessionStatus: existingSession?.status,
+        });
+        if (existingSession && ['completed', 'failed', 'stopped'].includes(existingSession.status)) {
+            await releaseClaim(sessionId);
+            if (existingSession.workerId) {
+                await removeWorkerSession(existingSession.workerId, sessionId);
+            }
+            await updateSessionStatus(sessionId, 'pending');
+        }
+        if (existingSession && !existingSession.organizationId && payload.organizationId) {
+            await storeSessionState(sessionId, {
+                ...existingSession,
+                organizationId: payload.organizationId,
+                status: 'pending',
+            });
+        }
+        const work = {
+            sessionId,
+            issueId,
+            issueIdentifier,
+            priority: 2,
+            queuedAt: Date.now(),
+            prompt: effectivePrompt,
+            claudeSessionId: existingSession?.claudeSessionId || undefined,
+            workType: existingSession?.workType || 'inflight',
+        };
+        const dispatchResult = await dispatchWork(work);
+        if (dispatchResult.dispatched || dispatchResult.parked) {
+            promptLog.info('Follow-up prompt dispatched', {
+                sessionId,
+                issueIdentifier,
+                dispatched: dispatchResult.dispatched,
+                parked: dispatchResult.parked,
+            });
+        }
+        else {
+            promptLog.error('Failed to dispatch follow-up prompt');
+        }
+    }
+    // Acknowledge prompt receipt
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const truncatedPrompt = effectivePrompt.length > 100
+            ? `${effectivePrompt.substring(0, 100)}...`
+            : effectivePrompt;
+        await emitActivity(linearClient, sessionId, 'thought', `Follow-up received: "${truncatedPrompt}" - Processing...`);
+    }
+    catch (err) {
+        promptLog.error('Failed to emit prompt acknowledgment activity', { error: err });
+    }
+    return null; // Continue processing
+}

package/dist/src/webhook/handlers/session-updated.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle agent session 'update' events — stop signal from user.
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@supaku/agentfactory-linear';
+import type { WebhookConfig } from '../../types.js';
+import type { createLogger } from '@supaku/agentfactory-server';
+export declare function handleSessionUpdated(config: WebhookConfig, payload: LinearWebhookPayload, rawPayload: Record<string, unknown>, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=session-updated.d.ts.map

package/dist/src/webhook/handlers/session-updated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-updated.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/session-updated.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAE/D,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA6B9B"}

package/dist/src/webhook/handlers/session-updated.js

@@ -0,0 +1,29 @@
+/**
+ * Handle agent session 'update' events — stop signal from user.
+ */
+import { NextResponse } from 'next/server';
+import { handleStopSignal } from '../utils.js';
+export async function handleSessionUpdated(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    if (!agentSession) {
+        log.warn('AgentSessionEvent updated missing agentSession field');
+        return NextResponse.json({ success: true, skipped: true, reason: 'missing_agent_session' });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const newState = agentSession.state;
+    const updatedFrom = rawPayload.updatedFrom;
+    const previousState = updatedFrom?.state;
+    const updateLog = log.child({ sessionId, issueId });
+    updateLog.info('Agent session updated', {
+        newState,
+        previousState,
+    });
+    // Check if this is a stop signal (state changed to completed/failed)
+    if (newState === 'completed' || newState === 'failed') {
+        updateLog.info('Stop signal received via updated webhook', { previousState });
+        await handleStopSignal(config, sessionId, issueId, payload.organizationId);
+    }
+    return null; // Continue processing other handlers
+}

package/dist/src/webhook/processor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Webhook Processor — Main Entry Point
+ *
+ * Receives Linear webhook events, verifies signatures, runs idempotency
+ * checks, and dispatches to sub-handlers.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { WebhookConfig } from '../types.js';
+/**
+ * Create webhook route handlers from config.
+ *
+ * Returns { POST, GET } for use as Next.js App Router exports.
+ */
+export declare function createWebhookHandler(config: WebhookConfig): {
+    POST: (request: NextRequest) => Promise<NextResponse<unknown>>;
+    GET: () => Promise<NextResponse<{
+        status: string;
+        endpoint: string;
+        description: string;
+    }>>;
+};
+//# sourceMappingURL=processor.d.ts.map

package/dist/src/webhook/processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../src/webhook/processor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AASvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAShD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa;oBAC3B,WAAW;;;;;;EA2FzC"}

package/dist/src/webhook/processor.js

@@ -0,0 +1,98 @@
+/**
+ * Webhook Processor — Main Entry Point
+ *
+ * Receives Linear webhook events, verifies signatures, runs idempotency
+ * checks, and dispatches to sub-handlers.
+ */
+import { NextResponse } from 'next/server';
+import { isAgentSessionCreated, isAgentSessionPrompted, isAgentSessionUpdated, isIssueUpdate, } from '@supaku/agentfactory-linear';
+import { createLogger, generateRequestId } from '@supaku/agentfactory-server';
+import { verifyWebhookSignature } from './signature.js';
+import { handleSessionCreated } from './handlers/session-created.js';
+import { handleSessionUpdated } from './handlers/session-updated.js';
+import { handleSessionPrompted } from './handlers/session-prompted.js';
+import { handleIssueUpdated } from './handlers/issue-updated.js';
+const baseLogger = createLogger('webhook');
+/**
+ * Create webhook route handlers from config.
+ *
+ * Returns { POST, GET } for use as Next.js App Router exports.
+ */
+export function createWebhookHandler(config) {
+    async function POST(request) {
+        const startTime = Date.now();
+        const requestId = generateRequestId();
+        const log = baseLogger.child({ requestId });
+        try {
+            const body = await request.text();
+            const signature = request.headers.get('linear-signature');
+            // Verify webhook signature
+            const webhookSecret = config.webhookSecret ?? process.env.LINEAR_WEBHOOK_SECRET;
+            if (!webhookSecret) {
+                const isProduction = process.env.NODE_ENV === 'production' ||
+                    process.env.VERCEL_ENV === 'production';
+                if (isProduction) {
+                    log.error('LINEAR_WEBHOOK_SECRET not configured - rejecting webhook in production');
+                    return NextResponse.json({ error: 'Service unavailable', message: 'Webhook signature verification not configured' }, { status: 503 });
+                }
+                else {
+                    log.warn('LINEAR_WEBHOOK_SECRET not configured - skipping signature verification in development');
+                }
+            }
+            else {
+                if (!verifyWebhookSignature(body, signature, webhookSecret)) {
+                    log.warn('Invalid webhook signature');
+                    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
+                }
+            }
+            const payload = JSON.parse(body);
+            log.info('Webhook received', {
+                webhookType: payload.type,
+                webhookAction: payload.action,
+                workspaceId: payload.organizationId,
+            });
+            const rawPayload = payload;
+            // Handle agent session 'create' events
+            if (isAgentSessionCreated(payload)) {
+                const result = await handleSessionCreated(config, payload, rawPayload, log);
+                if (result)
+                    return result;
+            }
+            // Handle agent session 'update' events (stop signal)
+            if (isAgentSessionUpdated(payload)) {
+                const result = await handleSessionUpdated(config, payload, rawPayload, log);
+                if (result)
+                    return result;
+            }
+            // Handle agent session 'prompted' events (follow-up messages)
+            if (isAgentSessionPrompted(payload)) {
+                const result = await handleSessionPrompted(config, payload, rawPayload, log);
+                if (result)
+                    return result;
+            }
+            // Handle Issue update events (status transitions)
+            if (isIssueUpdate(payload)) {
+                const result = await handleIssueUpdated(config, payload, log);
+                if (result)
+                    return result;
+            }
+            const durationMs = Date.now() - startTime;
+            log.info('Webhook processed', { durationMs });
+            return NextResponse.json({ success: true, duration: durationMs, requestId });
+        }
+        catch (err) {
+            const durationMs = Date.now() - startTime;
+            log.error('Webhook error', { error: err, durationMs });
+            return NextResponse.json({ error: 'Internal server error', requestId }, { status: 500 });
+        }
+    }
+    async function GET() {
+        baseLogger.debug('Health check requested');
+        return NextResponse.json({
+            status: 'ok',
+            endpoint: '/webhook',
+            description: 'Linear webhook receiver',
+        });
+    }
+    return { POST, GET };
+}

package/dist/src/webhook/signature.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Webhook Signature Verification
+ *
+ * HMAC-SHA256 verification for Linear webhook signatures.
+ * @see https://developers.linear.app/docs/webhooks#validating-webhooks
+ */
+/**
+ * Verify a Linear webhook signature using HMAC-SHA256.
+ *
+ * @param body - Raw request body string
+ * @param signature - Value of the `linear-signature` header
+ * @param secret - The webhook signing secret
+ * @returns true if the signature is valid
+ */
+export declare function verifyWebhookSignature(body: string, signature: string | null, secret: string): boolean;
+//# sourceMappingURL=signature.d.ts.map

package/dist/src/webhook/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../src/webhook/signature.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAQT"}

package/dist/src/webhook/signature.js

@@ -0,0 +1,23 @@
+/**
+ * Webhook Signature Verification
+ *
+ * HMAC-SHA256 verification for Linear webhook signatures.
+ * @see https://developers.linear.app/docs/webhooks#validating-webhooks
+ */
+import crypto from 'crypto';
+/**
+ * Verify a Linear webhook signature using HMAC-SHA256.
+ *
+ * @param body - Raw request body string
+ * @param signature - Value of the `linear-signature` header
+ * @param secret - The webhook signing secret
+ * @returns true if the signature is valid
+ */
+export function verifyWebhookSignature(body, signature, secret) {
+    if (!signature)
+        return false;
+    const hmac = crypto.createHmac('sha256', secret);
+    hmac.update(body);
+    const digest = hmac.digest('hex');
+    return crypto.timingSafeEqual(Buffer.from(digest), Buffer.from(signature));
+}