@supaku/agentfactory-nextjs 0.3.0

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

@@ -0,0 +1,77 @@
+/**
+ * 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 '@supaku/agentfactory-server';
+import { createAgentSession } from '@supaku/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 });
+            }
+            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) {
+                log.error('Failed to forward activity to Linear', {
+                    error: linearError,
+                    sessionId,
+                });
+                return NextResponse.json({
+                    forwarded: false,
+                    reason: 'Failed to forward to Linear',
+                });
+            }
+        }
+        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;AAcvD,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,oCA6FzE"}

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

@@ -0,0 +1,87 @@
+/**
+ * POST /api/sessions/[id]/claim
+ *
+ * Claim a session for processing.
+ * Uses atomic operations to prevent race conditions.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { claimWork, requeueWork, releaseClaim, claimSession, getSessionState, addWorkerSession, createLogger, } from '@supaku/agentfactory-server';
+const log = createLogger('api:sessions:claim');
+export function createSessionClaimHandler() {
+    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 } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            const work = await claimWork(sessionId, workerId);
+            if (!work) {
+                log.debug('Failed to claim work from queue', { sessionId, workerId });
+                return NextResponse.json({
+                    claimed: false,
+                    reason: 'Work item not available or already claimed',
+                });
+            }
+            const claimed = await claimSession(sessionId, workerId);
+            if (!claimed) {
+                const sessionState = await getSessionState(sessionId);
+                if (!sessionState) {
+                    log.warn('Session state expired, dropping orphaned work item', {
+                        sessionId,
+                        workerId,
+                        issueIdentifier: work.issueIdentifier,
+                    });
+                    await releaseClaim(sessionId);
+                    return NextResponse.json({
+                        claimed: false,
+                        reason: 'Session state expired, work item dropped',
+                    });
+                }
+                if (sessionState.status !== 'pending') {
+                    log.warn('Session not in pending status, dropping work item', {
+                        sessionId,
+                        workerId,
+                        issueIdentifier: work.issueIdentifier,
+                        sessionStatus: sessionState.status,
+                    });
+                    await releaseClaim(sessionId);
+                    return NextResponse.json({
+                        claimed: false,
+                        reason: `Session in ${sessionState.status} status, work item dropped`,
+                    });
+                }
+                log.warn('Transient failure updating session state, re-queuing', {
+                    sessionId,
+                    workerId,
+                });
+                await requeueWork(work);
+                return NextResponse.json({
+                    claimed: false,
+                    reason: 'Session state update failed, work re-queued',
+                });
+            }
+            await addWorkerSession(workerId, sessionId);
+            const session = await getSessionState(sessionId);
+            log.info('Session claimed', {
+                sessionId,
+                workerId,
+                issueIdentifier: work.issueIdentifier,
+            });
+            return NextResponse.json({
+                claimed: true,
+                session,
+                work,
+            });
+        }
+        catch (error) {
+            log.error('Failed to claim session', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to claim session' }, { status: 500 });
+        }
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * POST /api/sessions/[id]/completion
+ *
+ * Post agent completion comment to Linear.
+ * Uses multi-comment splitting for long messages.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionCompletionHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=completion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/completion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;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;AAWD,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,WAAW,IACrC,SAAS,WAAW,EAAE,YAAY,WAAW,oCA6FzE"}

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

@@ -0,0 +1,82 @@
+/**
+ * POST /api/sessions/[id]/completion
+ *
+ * Post agent completion comment to Linear.
+ * Uses multi-comment splitting for long messages.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@supaku/agentfactory-server';
+import { buildCompletionComments } from '@supaku/agentfactory-linear';
+const log = createLogger('api:sessions:completion');
+export function createSessionCompletionHandler(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, summary, planItems = [] } = body;
+            if (!summary || typeof summary !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'summary is required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (workerId && session.workerId && session.workerId !== workerId) {
+                return NextResponse.json({ error: 'Forbidden', message: 'Session is owned by another worker' }, { status: 403 });
+            }
+            const comments = buildCompletionComments(summary, planItems, sessionId);
+            log.info('Posting completion comments', {
+                sessionId,
+                issueId: session.issueId,
+                parts: comments.length,
+                summaryLength: summary.length,
+            });
+            const linearClient = await config.linearClient.getClient(session.organizationId);
+            let postedCount = 0;
+            const errors = [];
+            for (const chunk of comments) {
+                try {
+                    await linearClient.createComment(session.issueId, chunk.body);
+                    postedCount++;
+                    log.debug(`Posted completion comment part ${chunk.partNumber}/${chunk.totalParts}`, {
+                        sessionId,
+                        issueId: session.issueId,
+                    });
+                    if (chunk.partNumber < chunk.totalParts) {
+                        await new Promise((resolve) => setTimeout(resolve, 100));
+                    }
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    errors.push(`Part ${chunk.partNumber}: ${errorMsg}`);
+                    log.error(`Failed to post completion comment part ${chunk.partNumber}`, {
+                        error,
+                        sessionId,
+                        issueId: session.issueId,
+                    });
+                }
+            }
+            if (postedCount === 0) {
+                return NextResponse.json({
+                    error: 'Internal Server Error',
+                    message: 'Failed to post any completion comments',
+                    errors,
+                }, { status: 500 });
+            }
+            return NextResponse.json({
+                posted: true,
+                partsPosted: postedCount,
+                totalParts: comments.length,
+                errors: errors.length > 0 ? errors : undefined,
+            });
+        }
+        catch (error) {
+            log.error('Failed to process completion', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process completion' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/external-urls.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/external-urls
+ *
+ * Update external URLs for an agent session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionExternalUrlsHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=external-urls.d.ts.map

package/dist/src/handlers/sessions/external-urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-urls.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/external-urls.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvD,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;AAOD,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,WAAW,IACvC,SAAS,WAAW,EAAE,YAAY,WAAW,oCAwEzE"}

package/dist/src/handlers/sessions/external-urls.js

@@ -0,0 +1,59 @@
+/**
+ * POST /api/sessions/[id]/external-urls
+ *
+ * Update external URLs for an agent session.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@supaku/agentfactory-server';
+const log = createLogger('api:sessions:external-urls');
+export function createSessionExternalUrlsHandler(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 { externalUrls, workspaceId } = body;
+            if (!externalUrls || !Array.isArray(externalUrls)) {
+                return NextResponse.json({ error: 'Bad Request', message: 'externalUrls array is required' }, { status: 400 });
+            }
+            for (const extUrl of externalUrls) {
+                if (!extUrl.label || !extUrl.url) {
+                    return NextResponse.json({ error: 'Bad Request', message: 'Each external URL must have label and url' }, { status: 400 });
+                }
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            const effectiveWorkspaceId = workspaceId || session.organizationId;
+            if (!effectiveWorkspaceId) {
+                log.warn('No workspace ID available, falling back to default client', {
+                    sessionId,
+                    hasWorkspaceIdInRequest: !!workspaceId,
+                    hasOrganizationIdInSession: !!session.organizationId,
+                });
+            }
+            const linearClient = await config.linearClient.getClient(effectiveWorkspaceId);
+            await linearClient.updateAgentSession({
+                sessionId,
+                externalUrls,
+            });
+            log.info('External URLs updated', {
+                sessionId,
+                urlCount: externalUrls.length,
+                labels: externalUrls.map((u) => u.label),
+            });
+            return NextResponse.json({
+                updated: true,
+                externalUrls,
+            });
+        }
+        catch (error) {
+            log.error('Failed to update external URLs', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to update external URLs' }, { status: 500 });
+        }
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * GET /api/sessions/[id]
+ * Returns a single agent session by ID
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { AgentSessionResponse } from './list.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionGetHandler(): (_request: NextRequest, { params }: RouteParams) => Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<{
+    session: AgentSessionResponse;
+}>>;
+export {};
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/get.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAIrD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAwBD,wBAAgB,uBAAuB,KACX,UAAU,WAAW,EAAE,YAAY,WAAW;;;;;IAwBzE"}

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

@@ -0,0 +1,46 @@
+/**
+ * GET /api/sessions/[id]
+ * Returns a single agent session by ID
+ */
+import { NextResponse } from 'next/server';
+import { getSessionState, createLogger } from '@supaku/agentfactory-server';
+const log = createLogger('api:sessions:[id]');
+function toResponse(session) {
+    return {
+        id: session.linearSessionId,
+        linearSessionId: session.linearSessionId,
+        issueId: session.issueId,
+        identifier: session.issueIdentifier || session.issueId.slice(0, 8),
+        claudeSessionId: session.claudeSessionId || undefined,
+        status: session.status,
+        createdAt: new Date(session.createdAt * 1000).toISOString(),
+        updatedAt: new Date(session.updatedAt * 1000).toISOString(),
+        worktreePath: session.worktreePath,
+        workerId: session.workerId || undefined,
+        queuedAt: session.queuedAt
+            ? new Date(session.queuedAt).toISOString()
+            : undefined,
+        claimedAt: session.claimedAt
+            ? new Date(session.claimedAt * 1000).toISOString()
+            : undefined,
+        agentId: session.agentId || undefined,
+    };
+}
+export function createSessionGetHandler() {
+    return async function GET(_request, { params }) {
+        const { id: sessionId } = await params;
+        try {
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            return NextResponse.json({
+                session: toResponse(session),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch session', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to fetch session' }, { status: 500 });
+        }
+    };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * GET /api/sessions
+ * Returns list of all agent sessions from Redis
+ */
+import { NextResponse } from 'next/server';
+export interface AgentSessionResponse {
+    id: string;
+    linearSessionId: string;
+    issueId: string;
+    identifier: string;
+    claudeSessionId?: string;
+    status: 'pending' | 'claimed' | 'running' | 'finalizing' | 'completed' | 'failed' | 'stopped';
+    createdAt: string;
+    updatedAt: string;
+    worktreePath: string;
+    workerId?: string;
+    queuedAt?: string;
+    claimedAt?: string;
+    agentId?: string;
+}
+export declare function createSessionListHandler(): () => Promise<NextResponse<{
+    sessions: AgentSessionResponse[];
+    count: number;
+    timestamp: string;
+}>>;
+//# sourceMappingURL=list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/list.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC7F,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAwBD,wBAAgB,wBAAwB;;;;IAsBvC"}

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

@@ -0,0 +1,50 @@
+/**
+ * GET /api/sessions
+ * Returns list of all agent sessions from Redis
+ */
+import { NextResponse } from 'next/server';
+import { getAllSessions, createLogger } from '@supaku/agentfactory-server';
+const log = createLogger('api/sessions');
+function toResponse(session) {
+    return {
+        id: session.linearSessionId,
+        linearSessionId: session.linearSessionId,
+        issueId: session.issueId,
+        identifier: session.issueIdentifier || session.issueId.slice(0, 8),
+        claudeSessionId: session.claudeSessionId || undefined,
+        status: session.status,
+        createdAt: new Date(session.createdAt * 1000).toISOString(),
+        updatedAt: new Date(session.updatedAt * 1000).toISOString(),
+        worktreePath: session.worktreePath,
+        workerId: session.workerId || undefined,
+        queuedAt: session.queuedAt
+            ? new Date(session.queuedAt).toISOString()
+            : undefined,
+        claimedAt: session.claimedAt
+            ? new Date(session.claimedAt * 1000).toISOString()
+            : undefined,
+        agentId: session.agentId || undefined,
+    };
+}
+export function createSessionListHandler() {
+    return async function GET() {
+        try {
+            const allSessions = await getAllSessions();
+            const sessions = allSessions.map(toResponse);
+            return NextResponse.json({
+                sessions,
+                count: sessions.length,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch sessions', { error });
+            return NextResponse.json({
+                sessions: [],
+                count: 0,
+                timestamp: new Date().toISOString(),
+                error: 'Failed to fetch sessions from Redis',
+            });
+        }
+    };
+}

package/dist/src/handlers/sessions/lock-refresh.d.ts

@@ -0,0 +1,14 @@
+/**
+ * POST /api/sessions/[id]/lock-refresh
+ *
+ * Refresh the issue lock TTL for an active session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionLockRefreshHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=lock-refresh.d.ts.map

package/dist/src/handlers/sessions/lock-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-refresh.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/lock-refresh.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAMvD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAED,wBAAgB,+BAA+B,KAClB,SAAS,WAAW,EAAE,YAAY,WAAW,oCA6CzE"}

package/dist/src/handlers/sessions/lock-refresh.js

@@ -0,0 +1,38 @@
+/**
+ * POST /api/sessions/[id]/lock-refresh
+ *
+ * Refresh the issue lock TTL for an active session.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, refreshIssueLockTTL, createLogger } from '@supaku/agentfactory-server';
+const log = createLogger('api:sessions:lock-refresh');
+export function createSessionLockRefreshHandler() {
+    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, issueId } = body;
+            if (!workerId || !issueId) {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId and issueId are 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 });
+            }
+            const refreshed = await refreshIssueLockTTL(issueId);
+            log.debug('Lock TTL refreshed', { sessionId, issueId, refreshed });
+            return NextResponse.json({ refreshed });
+        }
+        catch (error) {
+            log.error('Failed to refresh lock TTL', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to refresh lock TTL' }, { status: 500 });
+        }
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/progress.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvD,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;AAeD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,WAAW,IACnC,SAAS,WAAW,EAAE,YAAY,WAAW,oCAsFzE"}