@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/handlers/oauth/callback.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OAuth Callback Handler for Linear
+ *
+ * Exchanges an authorization code for an access token and stores it
+ * in Redis for workspace-specific token resolution.
+ *
+ * @see https://developers.linear.app/docs/oauth/authentication
+ */
+import type { RouteHandler } from '../../types.js';
+/**
+ * Configuration for the OAuth callback handler.
+ */
+export interface OAuthConfig {
+    /** Linear OAuth client ID (defaults to LINEAR_CLIENT_ID env) */
+    clientId?: string;
+    /** Linear OAuth client secret (defaults to LINEAR_CLIENT_SECRET env) */
+    clientSecret?: string;
+    /** Application URL for redirect URI (defaults to NEXT_PUBLIC_APP_URL env) */
+    appUrl?: string;
+    /** Redirect path on success (defaults to '/?oauth=success') */
+    successRedirect?: string;
+}
+/**
+ * Create an OAuth callback route handler for Linear.
+ *
+ * @example
+ * ```typescript
+ * // In app/callback/route.ts:
+ * import { createOAuthCallbackHandler } from '@renseiai/agentfactory-nextjs'
+ * export const { GET } = createOAuthCallbackHandler()
+ * ```
+ */
+export declare function createOAuthCallbackHandler(config?: OAuthConfig): {
+    GET: RouteHandler;
+};
+//# sourceMappingURL=callback.d.ts.map

package/dist/src/handlers/oauth/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../../../src/handlers/oauth/callback.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAID;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,YAAY,CAAA;CAAE,CAkGtF"}

package/dist/src/handlers/oauth/callback.js

@@ -0,0 +1,96 @@
+/**
+ * OAuth Callback Handler for Linear
+ *
+ * Exchanges an authorization code for an access token and stores it
+ * in Redis for workspace-specific token resolution.
+ *
+ * @see https://developers.linear.app/docs/oauth/authentication
+ */
+import { NextResponse } from 'next/server';
+import { storeToken, fetchOrganization, isRedisConfigured, createLogger, generateRequestId, } from '@renseiai/agentfactory-server';
+const baseLogger = createLogger('oauth-callback');
+/**
+ * Create an OAuth callback route handler for Linear.
+ *
+ * @example
+ * ```typescript
+ * // In app/callback/route.ts:
+ * import { createOAuthCallbackHandler } from '@renseiai/agentfactory-nextjs'
+ * export const { GET } = createOAuthCallbackHandler()
+ * ```
+ */
+export function createOAuthCallbackHandler(config) {
+    return {
+        GET: async (request) => {
+            const requestId = generateRequestId();
+            const log = baseLogger.child({ requestId });
+            const clientId = config?.clientId ?? process.env.LINEAR_CLIENT_ID;
+            const clientSecret = config?.clientSecret ?? process.env.LINEAR_CLIENT_SECRET;
+            const appUrl = config?.appUrl
+                ?? process.env.NEXT_PUBLIC_APP_URL
+                ?? (process.env.VERCEL_PROJECT_PRODUCTION_URL && `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`)
+                ?? (process.env.VERCEL_URL && `https://${process.env.VERCEL_URL}`)
+                ?? 'http://localhost:3002';
+            const successRedirect = config?.successRedirect ?? '/?oauth=success';
+            const code = request.nextUrl.searchParams.get('code');
+            const error = request.nextUrl.searchParams.get('error');
+            const errorDescription = request.nextUrl.searchParams.get('error_description');
+            if (error) {
+                log.error('OAuth error from Linear', { oauthError: error, errorDescription });
+                return NextResponse.json({ error, description: errorDescription, requestId }, { status: 400 });
+            }
+            if (!code) {
+                log.warn('Missing authorization code');
+                return NextResponse.json({ error: 'Missing authorization code', requestId }, { status: 400 });
+            }
+            if (!clientId || !clientSecret) {
+                log.error('OAuth credentials not configured');
+                return NextResponse.json({ error: 'OAuth not configured', requestId }, { status: 500 });
+            }
+            try {
+                log.debug('Exchanging authorization code for token');
+                const tokenResponse = await fetch('https://api.linear.app/oauth/token', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: new URLSearchParams({
+                        grant_type: 'authorization_code',
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                        redirect_uri: `${appUrl}/callback`,
+                        code,
+                    }),
+                });
+                if (!tokenResponse.ok) {
+                    const errorText = await tokenResponse.text();
+                    log.error('Token exchange failed', {
+                        statusCode: tokenResponse.status,
+                        errorDetails: errorText,
+                    });
+                    return NextResponse.json({ error: 'Token exchange failed', details: errorText, requestId }, { status: 400 });
+                }
+                const tokenData = (await tokenResponse.json());
+                if (isRedisConfigured()) {
+                    const organization = await fetchOrganization(tokenData.access_token);
+                    if (organization) {
+                        await storeToken(organization.id, tokenData, organization.name);
+                        log.info('OAuth successful, token stored', {
+                            workspaceId: organization.id,
+                            workspaceName: organization.name,
+                        });
+                    }
+                    else {
+                        log.warn('OAuth successful but could not fetch organization info - token not stored');
+                    }
+                }
+                else {
+                    log.info('OAuth successful, token received (Redis not configured for storage)');
+                }
+                return NextResponse.redirect(new URL(successRedirect, appUrl));
+            }
+            catch (err) {
+                log.error('OAuth callback error', { error: err });
+                return NextResponse.json({ error: 'Internal server error', requestId }, { status: 500 });
+            }
+        },
+    };
+}

package/dist/src/handlers/public/session-detail.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GET /api/public/sessions/:id
+ *
+ * Returns sanitized session detail for a single session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+export interface PublicSessionDetailResponse {
+    id: string;
+    identifier: string;
+    status: 'queued' | 'parked' | 'working' | 'completed' | 'failed';
+    workType: string;
+    startedAt: string;
+    duration: number;
+    timeline: {
+        created: string;
+        queued?: string;
+        started?: string;
+        completed?: string;
+    };
+}
+export declare function createPublicSessionDetailHandler(): (_request: NextRequest, { params }: {
+    params: Promise<{
+        id: string;
+    }>;
+}) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    session: PublicSessionDetailResponse;
+    timestamp: string;
+}>>;
+//# sourceMappingURL=session-detail.d.ts.map

package/dist/src/handlers/public/session-detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-detail.d.ts","sourceRoot":"","sources":["../../../../src/handlers/public/session-detail.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAYvD,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;IAChE,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,CAAA;CACF;AA6ED,wBAAgB,gCAAgC,KAE5C,UAAU,WAAW,EACrB,YAAY;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;;IAoClD"}

package/dist/src/handlers/public/session-detail.js

@@ -0,0 +1,91 @@
+/**
+ * GET /api/public/sessions/:id
+ *
+ * Returns sanitized session detail for a single session.
+ */
+import { NextResponse } from 'next/server';
+import { getAllSessions, isSessionInQueue, hashSessionId, isValidPublicId, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api/public/sessions/[id]');
+function toPublicStatus(status, isParked = false) {
+    switch (status) {
+        case 'pending':
+            return isParked ? 'parked' : 'queued';
+        case 'claimed':
+        case 'running':
+            return 'working';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+        case 'stopped':
+            return 'failed';
+        default:
+            return 'queued';
+    }
+}
+async function toPublicSessionDetail(session) {
+    const now = Math.floor(Date.now() / 1000);
+    const startTime = session.queuedAt
+        ? Math.floor(session.queuedAt / 1000)
+        : session.createdAt;
+    const endTime = ['completed', 'failed', 'stopped'].includes(session.status)
+        ? session.updatedAt
+        : now;
+    const isComplete = ['completed', 'failed', 'stopped'].includes(session.status);
+    let isParked = false;
+    if (session.status === 'pending') {
+        const inQueue = await isSessionInQueue(session.linearSessionId);
+        isParked = !inQueue;
+    }
+    return {
+        id: hashSessionId(session.linearSessionId),
+        identifier: session.issueIdentifier || 'Unknown',
+        status: toPublicStatus(session.status, isParked),
+        workType: session.workType || 'development',
+        startedAt: new Date(startTime * 1000).toISOString(),
+        duration: endTime - startTime,
+        timeline: {
+            created: new Date(session.createdAt * 1000).toISOString(),
+            queued: session.queuedAt
+                ? new Date(session.queuedAt).toISOString()
+                : undefined,
+            started: session.claimedAt
+                ? new Date(session.claimedAt * 1000).toISOString()
+                : undefined,
+            completed: isComplete
+                ? new Date(session.updatedAt * 1000).toISOString()
+                : undefined,
+        },
+    };
+}
+async function findSessionByPublicId(publicId) {
+    const allSessions = await getAllSessions();
+    for (const session of allSessions) {
+        if (hashSessionId(session.linearSessionId) === publicId) {
+            return session;
+        }
+    }
+    return null;
+}
+export function createPublicSessionDetailHandler() {
+    return async function GET(_request, { params }) {
+        const { id: publicId } = await params;
+        if (!isValidPublicId(publicId)) {
+            return NextResponse.json({ error: 'Invalid session ID format' }, { status: 400 });
+        }
+        try {
+            const session = await findSessionByPublicId(publicId);
+            if (!session) {
+                return NextResponse.json({ error: 'Session not found' }, { status: 404 });
+            }
+            const publicSession = await toPublicSessionDetail(session);
+            return NextResponse.json({
+                session: publicSession,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch public session detail', { error, publicId });
+            return NextResponse.json({ error: 'Failed to fetch session' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/public/sessions-list.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GET /api/public/sessions
+ *
+ * Returns sanitized session data for public display.
+ */
+import { NextResponse } from 'next/server';
+export interface PublicSessionResponse {
+    id: string;
+    identifier: string;
+    status: 'queued' | 'parked' | 'working' | 'completed' | 'failed' | 'stopped';
+    workType: string;
+    startedAt: string;
+    duration: number;
+    costUsd?: number;
+    provider?: string;
+}
+export declare function createPublicSessionsListHandler(): () => Promise<NextResponse<{
+    sessions: PublicSessionResponse[];
+    count: number;
+    timestamp: string;
+}>>;
+//# sourceMappingURL=sessions-list.d.ts.map

package/dist/src/handlers/public/sessions-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions-list.d.ts","sourceRoot":"","sources":["../../../../src/handlers/public/sessions-list.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAW1C,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC5E,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAqDD,wBAAgB,+BAA+B;;;;IA6B9C"}

package/dist/src/handlers/public/sessions-list.js

@@ -0,0 +1,75 @@
+/**
+ * GET /api/public/sessions
+ *
+ * Returns sanitized session data for public display.
+ */
+import { NextResponse } from 'next/server';
+import { getAllSessions, isSessionInQueue, hashSessionId, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api/public/sessions');
+function toPublicStatus(status, isParked = false) {
+    switch (status) {
+        case 'pending':
+            return isParked ? 'parked' : 'queued';
+        case 'claimed':
+        case 'running':
+        case 'finalizing':
+            return 'working';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+            return 'failed';
+        case 'stopped':
+            return 'stopped';
+        default:
+            return 'queued';
+    }
+}
+async function toPublicSession(session) {
+    const now = Math.floor(Date.now() / 1000);
+    const startTime = session.queuedAt
+        ? Math.floor(session.queuedAt / 1000)
+        : session.createdAt;
+    const endTime = ['completed', 'failed', 'stopped'].includes(session.status)
+        ? session.updatedAt
+        : now;
+    let isParked = false;
+    if (session.status === 'pending') {
+        const inQueue = await isSessionInQueue(session.linearSessionId);
+        isParked = !inQueue;
+    }
+    return {
+        id: hashSessionId(session.linearSessionId),
+        identifier: session.issueIdentifier || 'Unknown',
+        status: toPublicStatus(session.status, isParked),
+        workType: session.workType || 'development',
+        startedAt: new Date(startTime * 1000).toISOString(),
+        duration: endTime - startTime,
+        costUsd: session.totalCostUsd,
+        provider: session.provider,
+    };
+}
+export function createPublicSessionsListHandler() {
+    return async function GET() {
+        try {
+            const allSessions = await getAllSessions();
+            const publicSessions = await Promise.all(allSessions.map(toPublicSession));
+            publicSessions.sort((a, b) => {
+                return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+            });
+            return NextResponse.json({
+                sessions: publicSessions,
+                count: publicSessions.length,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch public sessions', { error });
+            return NextResponse.json({
+                sessions: [],
+                count: 0,
+                timestamp: new Date().toISOString(),
+                error: 'Failed to fetch sessions',
+            }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/public/stats.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GET /api/public/stats
+ *
+ * Returns aggregate statistics only - no sensitive data.
+ */
+import { NextResponse } from 'next/server';
+export interface PublicStatsResponse {
+    workersOnline: number;
+    agentsWorking: number;
+    queueDepth: number;
+    completedToday: number;
+    availableCapacity: number;
+    totalCostToday: number;
+    totalCostAllTime: number;
+    sessionCountToday: number;
+}
+export declare function createPublicStatsHandler(): () => Promise<NextResponse<{
+    timestamp: string;
+    workersOnline: number;
+    agentsWorking: number;
+    queueDepth: number;
+    completedToday: number;
+    availableCapacity: number;
+    totalCostToday: number;
+    totalCostAllTime: number;
+    sessionCountToday: number;
+}>>;
+//# sourceMappingURL=stats.d.ts.map

package/dist/src/handlers/public/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../../src/handlers/public/stats.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAUD,wBAAgB,wBAAwB;;mBAlBvB,MAAM;mBACN,MAAM;gBACT,MAAM;oBACF,MAAM;uBACH,MAAM;oBACT,MAAM;sBACJ,MAAM;uBACL,MAAM;IAiF1B"}

package/dist/src/handlers/public/stats.js

@@ -0,0 +1,66 @@
+/**
+ * GET /api/public/stats
+ *
+ * Returns aggregate statistics only - no sensitive data.
+ */
+import { NextResponse } from 'next/server';
+import { getAllSessions, listWorkers, getTotalCapacity, getQueueLength, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api/public/stats');
+function getTodayStart() {
+    const now = new Date();
+    const todayStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    return Math.floor(todayStart.getTime() / 1000);
+}
+export function createPublicStatsHandler() {
+    return async function GET() {
+        try {
+            // Fetch workers once and pass to getTotalCapacity to avoid
+            // redundant listWorkers() calls that can return different snapshots
+            const [allSessions, workers, queueLength] = await Promise.all([
+                getAllSessions(),
+                listWorkers(),
+                getQueueLength(),
+            ]);
+            const capacity = await getTotalCapacity(workers);
+            const todayStart = getTodayStart();
+            const agentsWorking = allSessions.filter((s) => s.status === 'running' || s.status === 'claimed').length;
+            const completedToday = allSessions.filter((s) => s.status === 'completed' &&
+                s.updatedAt >= todayStart).length;
+            const todaySessions = allSessions.filter((s) => s.updatedAt >= todayStart);
+            const totalCostToday = todaySessions
+                .reduce((sum, s) => sum + (s.totalCostUsd ?? 0), 0);
+            const totalCostAllTime = allSessions
+                .reduce((sum, s) => sum + (s.totalCostUsd ?? 0), 0);
+            const workersOnline = workers.filter((w) => w.status === 'active').length;
+            const stats = {
+                workersOnline,
+                agentsWorking,
+                queueDepth: queueLength,
+                completedToday,
+                availableCapacity: capacity.availableCapacity,
+                totalCostToday: Math.round(totalCostToday * 10000) / 10000,
+                totalCostAllTime: Math.round(totalCostAllTime * 10000) / 10000,
+                sessionCountToday: todaySessions.length,
+            };
+            return NextResponse.json({
+                ...stats,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            log.error('Failed to get public stats', { error });
+            return NextResponse.json({
+                workersOnline: 0,
+                agentsWorking: 0,
+                queueDepth: 0,
+                completedToday: 0,
+                availableCapacity: 0,
+                totalCostToday: 0,
+                totalCostAllTime: 0,
+                sessionCountToday: 0,
+                error: 'Failed to fetch stats',
+                timestamp: new Date().toISOString(),
+            }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/activity.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/activity
+ *
+ * Report agent activity to be forwarded to Linear.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionActivityHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=activity.d.ts.map

package/dist/src/handlers/sessions/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/activity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAIvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAUD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,WAAW,IACnC,SAAS,WAAW,EAAE,YAAY,WAAW,oCA+GzE"}

package/dist/src/handlers/sessions/activity.js

@@ -0,0 +1,93 @@
+/**
+ * POST /api/sessions/[id]/activity
+ *
+ * Report agent activity to be forwarded to Linear.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+import { createAgentSession } from '@renseiai/agentfactory-linear';
+const log = createLogger('api:sessions:activity');
+export function createSessionActivityHandler(config) {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = await request.json();
+            const { workerId, activity } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            if (!activity || !activity.type || !activity.content) {
+                return NextResponse.json({ error: 'Bad Request', message: 'activity with type and content is required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (session.workerId && session.workerId !== workerId) {
+                return NextResponse.json({ error: 'Forbidden', message: 'Session is owned by another worker' }, { status: 403 });
+            }
+            // Skip Linear forwarding for governor-generated fake session IDs.
+            // When the governor can't create a real agent session on Linear (e.g., OAuth
+            // token issue), it generates a local ID prefixed with "governor-". There's no
+            // corresponding session on Linear's side, so forwarding would always fail.
+            if (sessionId.startsWith('governor-')) {
+                log.debug('Skipping Linear forwarding for governor-generated session', {
+                    sessionId,
+                    activityType: activity.type,
+                });
+                return NextResponse.json({
+                    forwarded: false,
+                    reason: 'Governor-generated session — no Linear agent session exists',
+                });
+            }
+            try {
+                const linearClient = await config.linearClient.getClient(session.organizationId);
+                const agentSession = createAgentSession({
+                    client: linearClient.linearClient,
+                    issueId: session.issueId,
+                    sessionId,
+                    autoTransition: false,
+                });
+                switch (activity.type) {
+                    case 'thought':
+                        await agentSession.emitThought(activity.content);
+                        break;
+                    case 'action':
+                        await agentSession.emitAction(activity.toolName || 'Tool', activity.toolInput || {});
+                        break;
+                    case 'response':
+                        await agentSession.emitResponse(activity.content);
+                        break;
+                }
+                log.debug('Activity forwarded to Linear', {
+                    sessionId,
+                    activityType: activity.type,
+                    issueId: session.issueId,
+                });
+                return NextResponse.json({
+                    forwarded: true,
+                });
+            }
+            catch (linearError) {
+                const errorMessage = linearError instanceof Error ? linearError.message : String(linearError);
+                log.error('Failed to forward activity to Linear', {
+                    error: errorMessage,
+                    sessionId,
+                    issueId: session.issueId,
+                });
+                return NextResponse.json({
+                    forwarded: false,
+                    reason: `Failed to forward to Linear: ${errorMessage}`,
+                });
+            }
+        }
+        catch (error) {
+            log.error('Failed to process activity', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process activity' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/claim.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/claim
+ *
+ * Claim a session for processing.
+ * Uses atomic operations to prevent race conditions.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionClaimHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=claim.d.ts.map

package/dist/src/handlers/sessions/claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/claim.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAevD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAED,wBAAgB,yBAAyB,KACZ,SAAS,WAAW,EAAE,YAAY,WAAW,oCAoJzE"}