@renseiai/agentfactory-nextjs 0.8.0

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

@@ -0,0 +1,15 @@
+/**
+ * GET, POST /api/sessions/[id]/prompts
+ *
+ * Get pending prompts or claim a specific prompt.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionPromptsGetHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export declare function createSessionPromptsPostHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=prompts.d.ts.map

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

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

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

@@ -0,0 +1,91 @@
+/**
+ * GET, POST /api/sessions/[id]/prompts
+ *
+ * Get pending prompts or claim a specific prompt.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, getPendingPrompts, popPendingPrompt, claimPendingPrompt, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:prompts');
+export function createSessionPromptsGetHandler() {
+    return async function GET(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        const url = new URL(request.url);
+        const shouldPop = url.searchParams.get('pop') === 'true';
+        try {
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (shouldPop) {
+                const prompt = await popPendingPrompt(sessionId);
+                if (prompt) {
+                    log.info('Prompt popped successfully', {
+                        sessionId,
+                        promptId: prompt.id,
+                        promptLength: prompt.prompt.length,
+                    });
+                }
+                return NextResponse.json({
+                    prompt,
+                    hasMore: prompt ? true : false,
+                });
+            }
+            const prompts = await getPendingPrompts(sessionId);
+            if (prompts.length > 0) {
+                log.info('Prompts retrieved', {
+                    sessionId,
+                    promptCount: prompts.length,
+                    promptIds: prompts.map((p) => p.id),
+                });
+            }
+            return NextResponse.json({
+                prompts,
+                count: prompts.length,
+            });
+        }
+        catch (error) {
+            log.error('Failed to get pending prompts', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to get pending prompts' }, { status: 500 });
+        }
+    };
+}
+export function createSessionPromptsPostHandler() {
+    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 { promptId } = body;
+            if (!promptId || typeof promptId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'promptId is required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            const prompt = await claimPendingPrompt(sessionId, promptId);
+            if (!prompt) {
+                return NextResponse.json({ error: 'Not Found', message: 'Prompt not found or already claimed' }, { status: 404 });
+            }
+            log.info('Prompt claimed', {
+                sessionId,
+                promptId,
+                promptLength: prompt.prompt.length,
+            });
+            return NextResponse.json({
+                claimed: true,
+                prompt,
+            });
+        }
+        catch (error) {
+            log.error('Failed to claim prompt', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to claim prompt' }, { status: 500 });
+        }
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * GET, POST /api/sessions/[id]/status
+ *
+ * Report status update from worker or get current status.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionStatusPostHandler(config?: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export declare function createSessionStatusGetHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<import("@renseiai/agentfactory-server").AgentSessionState>>;
+export {};
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/status.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAiBvD,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;AAYD,wBAAgB,8BAA8B,CAAC,MAAM,CAAC,EAAE,WAAW,IACtC,SAAS,WAAW,EAAE,YAAY,WAAW,oCA0LzE;AAED,wBAAgB,6BAA6B,KACjB,SAAS,WAAW,EAAE,YAAY,WAAW;;;8EAsBxE"}

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

@@ -0,0 +1,187 @@
+/**
+ * GET, POST /api/sessions/[id]/status
+ *
+ * Report status update from worker or get current status.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, updateSessionStatus, updateSessionCostData, updateProviderSessionId, startSession, removeWorkerSession, releaseClaim, markAgentWorked, releaseIssueLock, promoteNextPendingWork, RedisProcessingStateStorage, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:status');
+const VALID_STATUSES = [
+    'running',
+    'finalizing',
+    'completed',
+    'failed',
+    'stopped',
+];
+const TERMINAL_STATUSES = ['completed', 'failed', 'stopped'];
+export function createSessionStatusPostHandler(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, status, providerSessionId, worktreePath, error: errorInfo, totalCostUsd, inputTokens, outputTokens } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            if (!status || !VALID_STATUSES.includes(status)) {
+                return NextResponse.json({
+                    error: 'Bad Request',
+                    message: `status must be one of: ${VALID_STATUSES.join(', ')}`,
+                }, { 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 });
+            }
+            if (status === 'running') {
+                if (worktreePath) {
+                    await startSession(sessionId, workerId, worktreePath);
+                }
+                else {
+                    await updateSessionStatus(sessionId, 'running');
+                }
+                if (providerSessionId) {
+                    await updateProviderSessionId(sessionId, providerSessionId);
+                }
+            }
+            else if (status === 'finalizing') {
+                await updateSessionStatus(sessionId, 'finalizing');
+            }
+            else if (TERMINAL_STATUSES.includes(status)) {
+                await updateSessionStatus(sessionId, status);
+                if (totalCostUsd != null || inputTokens != null || outputTokens != null) {
+                    await updateSessionCostData(sessionId, { totalCostUsd, inputTokens, outputTokens }).catch((err) => log.error('Failed to persist cost data', { sessionId, error: err }));
+                }
+                if (status === 'completed' && session.issueId) {
+                    try {
+                        await markAgentWorked(session.issueId, {
+                            issueIdentifier: session.issueIdentifier || 'unknown',
+                            sessionId: sessionId,
+                        });
+                        log.info('Issue marked as agent-worked', {
+                            issueId: session.issueId,
+                            sessionId,
+                        });
+                    }
+                    catch (err) {
+                        log.error('Failed to mark agent-worked', { sessionId, error: err });
+                    }
+                    // Mark research/backlog-creation phases as completed so the
+                    // governor does not re-dispatch the same top-of-funnel work.
+                    const phase = session.workType === 'research' ? 'research'
+                        : session.workType === 'backlog-creation' ? 'backlog-creation'
+                            : null;
+                    if (phase) {
+                        try {
+                            const processingState = new RedisProcessingStateStorage();
+                            await processingState.markPhaseCompleted(session.issueId, phase, sessionId);
+                            log.info('Processing phase marked complete', {
+                                issueId: session.issueId,
+                                phase,
+                                sessionId,
+                            });
+                        }
+                        catch (err) {
+                            log.error('Failed to mark processing phase complete', {
+                                sessionId,
+                                issueId: session.issueId,
+                                phase,
+                                error: err,
+                            });
+                        }
+                    }
+                }
+                // Emit a response activity to close the Linear agent session.
+                // Linear auto-transitions sessions to "complete" based on response activities.
+                if (config && session.linearSessionId && session.organizationId) {
+                    try {
+                        const linearClient = await config.linearClient.getClient(session.organizationId);
+                        const message = status === 'completed'
+                            ? 'Work completed successfully.'
+                            : status === 'failed'
+                                ? 'Agent encountered an error during execution.'
+                                : 'Agent was stopped.';
+                        await linearClient.createAgentActivity({
+                            agentSessionId: session.linearSessionId,
+                            content: { type: 'response', body: message },
+                            ephemeral: false,
+                        });
+                        log.info('Emitted completion response activity to close Linear session', {
+                            sessionId,
+                            linearSessionId: session.linearSessionId,
+                            status,
+                        });
+                    }
+                    catch (err) {
+                        log.warn('Failed to emit completion response activity', {
+                            sessionId,
+                            linearSessionId: session.linearSessionId,
+                            error: err,
+                        });
+                    }
+                }
+                await releaseClaim(sessionId);
+                await removeWorkerSession(workerId, sessionId);
+                if (session.issueId) {
+                    try {
+                        await releaseIssueLock(session.issueId);
+                        const promoted = await promoteNextPendingWork(session.issueId);
+                        if (promoted) {
+                            log.info('Promoted pending work after lock release', {
+                                issueId: session.issueId,
+                                promotedSessionId: promoted.sessionId,
+                                promotedWorkType: promoted.workType,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        log.error('Failed to release issue lock or promote pending work', {
+                            sessionId,
+                            issueId: session.issueId,
+                            error: err,
+                        });
+                    }
+                }
+            }
+            log.info('Session status updated', {
+                sessionId,
+                workerId,
+                status,
+                hasProviderSessionId: !!providerSessionId,
+                hasError: !!errorInfo,
+            });
+            const updatedSession = await getSessionState(sessionId);
+            return NextResponse.json({
+                updated: true,
+                session: updatedSession,
+            });
+        }
+        catch (error) {
+            log.error('Failed to update session status', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to update session status' }, { status: 500 });
+        }
+    };
+}
+export function createSessionStatusGetHandler() {
+    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);
+        }
+        catch (error) {
+            log.error('Failed to get session status', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to get session status' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/tool-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/tool-error
+ *
+ * Report a tool error as a Linear issue for tracking.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionToolErrorHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=tool-error.d.ts.map

package/dist/src/handlers/sessions/tool-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-error.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/tool-error.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;AAYD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,WAAW,IACpC,SAAS,WAAW,EAAE,YAAY,WAAW,oCA4HzE"}

package/dist/src/handlers/sessions/tool-error.js

@@ -0,0 +1,103 @@
+/**
+ * POST /api/sessions/[id]/tool-error
+ *
+ * Report a tool error as a Linear issue for tracking.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+import { createAgentSession, ENVIRONMENT_ISSUE_TYPES } from '@renseiai/agentfactory-linear';
+const log = createLogger('api:sessions:tool-error');
+export function createSessionToolErrorHandler(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, toolName, errorMessage, context } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            if (!toolName || typeof toolName !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'toolName is required' }, { status: 400 });
+            }
+            if (!errorMessage || typeof errorMessage !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'errorMessage 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.
+            if (sessionId.startsWith('governor-')) {
+                log.debug('Skipping Linear tool error report for governor-generated session', {
+                    sessionId,
+                    toolName,
+                });
+                return NextResponse.json({
+                    created: 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,
+                });
+                const issue = await agentSession.reportEnvironmentIssue(`Tool error: ${toolName}`, `The agent encountered an error while using the **${toolName}** tool.\n\n**Error:**\n\`\`\`\n${errorMessage}\n\`\`\``, {
+                    issueType: ENVIRONMENT_ISSUE_TYPES.TOOL,
+                    sourceIssueId: context?.issueIdentifier ?? session.issueId,
+                    additionalContext: {
+                        toolName,
+                        sessionId,
+                        workerId,
+                        ...context?.additionalContext,
+                    },
+                });
+                if (issue) {
+                    log.info('Tool error reported to Linear', {
+                        sessionId,
+                        toolName,
+                        issueIdentifier: issue.identifier,
+                    });
+                    return NextResponse.json({
+                        created: true,
+                        issue: {
+                            id: issue.id,
+                            identifier: issue.identifier,
+                            url: issue.url,
+                        },
+                    });
+                }
+                return NextResponse.json({
+                    created: false,
+                    reason: 'Failed to create issue in Linear',
+                });
+            }
+            catch (linearError) {
+                const errorMessage2 = linearError instanceof Error ? linearError.message : String(linearError);
+                log.error('Failed to report tool error to Linear', {
+                    error: errorMessage2,
+                    sessionId,
+                    toolName,
+                });
+                return NextResponse.json({
+                    created: false,
+                    reason: `Failed to report to Linear: ${errorMessage2}`,
+                });
+            }
+        }
+        catch (error) {
+            log.error('Failed to process tool error report', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process tool error report' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/transfer-ownership.d.ts

@@ -0,0 +1,14 @@
+/**
+ * POST /api/sessions/[id]/transfer-ownership
+ *
+ * Transfer session ownership to a new worker.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionTransferOwnershipHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=transfer-ownership.d.ts.map

package/dist/src/handlers/sessions/transfer-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-ownership.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/transfer-ownership.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAYvD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAED,wBAAgB,qCAAqC,KACxB,SAAS,WAAW,EAAE,YAAY,WAAW,oCA8DzE"}

package/dist/src/handlers/sessions/transfer-ownership.js

@@ -0,0 +1,56 @@
+/**
+ * POST /api/sessions/[id]/transfer-ownership
+ *
+ * Transfer session ownership to a new worker.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { transferSessionOwnership, getSessionState, removeWorkerSession, addWorkerSession, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:transfer-ownership');
+export function createSessionTransferOwnershipHandler() {
+    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 { newWorkerId, oldWorkerId } = body;
+            if (!newWorkerId || typeof newWorkerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'newWorkerId is required' }, { status: 400 });
+            }
+            if (!oldWorkerId || typeof oldWorkerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'oldWorkerId is required' }, { status: 400 });
+            }
+            const result = await transferSessionOwnership(sessionId, newWorkerId, oldWorkerId);
+            if (!result.transferred) {
+                log.warn('Session ownership transfer failed', {
+                    sessionId,
+                    newWorkerId,
+                    oldWorkerId,
+                    reason: result.reason,
+                });
+                return NextResponse.json({
+                    transferred: false,
+                    reason: result.reason,
+                });
+            }
+            await removeWorkerSession(oldWorkerId, sessionId);
+            await addWorkerSession(newWorkerId, sessionId);
+            log.info('Session ownership transferred', {
+                sessionId,
+                oldWorkerId,
+                newWorkerId,
+            });
+            const session = await getSessionState(sessionId);
+            return NextResponse.json({
+                transferred: true,
+                session,
+            });
+        }
+        catch (error) {
+            log.error('Failed to transfer session ownership', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to transfer session ownership' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/workers/get-delete.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GET, DELETE /api/workers/[id]
+ *
+ * Get worker details or deregister a worker.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createWorkerDeleteHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export declare function createWorkerGetHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=get-delete.d.ts.map

package/dist/src/handlers/workers/get-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-delete.d.ts","sourceRoot":"","sources":["../../../../src/handlers/workers/get-delete.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,yBAAyB,KACV,SAAS,WAAW,EAAE,YAAY,WAAW,oCAyC3E;AAED,wBAAgB,sBAAsB,KACV,SAAS,WAAW,EAAE,YAAY,WAAW,oCAyBxE"}

package/dist/src/handlers/workers/get-delete.js

@@ -0,0 +1,58 @@
+/**
+ * GET, DELETE /api/workers/[id]
+ *
+ * Get worker details or deregister a worker.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { deregisterWorker, getWorker, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:workers:detail');
+export function createWorkerDeleteHandler() {
+    return async function DELETE(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: workerId } = await params;
+        try {
+            const worker = await getWorker(workerId);
+            if (!worker) {
+                return NextResponse.json({ error: 'Not Found', message: 'Worker not found' }, { status: 404 });
+            }
+            const result = await deregisterWorker(workerId);
+            if (!result.deregistered) {
+                return NextResponse.json({ error: 'Service Unavailable', message: 'Failed to deregister worker' }, { status: 503 });
+            }
+            log.info('Worker deregistered via API', {
+                workerId,
+                unclaimedSessions: result.unclaimedSessions.length,
+            });
+            return NextResponse.json({
+                deregistered: true,
+                unclaimedSessions: result.unclaimedSessions,
+            });
+        }
+        catch (error) {
+            log.error('Failed to deregister worker', { error, workerId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to deregister worker' }, { status: 500 });
+        }
+    };
+}
+export function createWorkerGetHandler() {
+    return async function GET(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: workerId } = await params;
+        try {
+            const worker = await getWorker(workerId);
+            if (!worker) {
+                return NextResponse.json({ error: 'Not Found', message: 'Worker not found' }, { status: 404 });
+            }
+            return NextResponse.json(worker);
+        }
+        catch (error) {
+            log.error('Failed to get worker', { error, workerId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to get worker' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/workers/heartbeat.d.ts

@@ -0,0 +1,14 @@
+/**
+ * POST /api/workers/[id]/heartbeat
+ *
+ * Send a heartbeat from a worker to keep registration active.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createWorkerHeartbeatHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/src/handlers/workers/heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../../src/handlers/workers/heartbeat.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,4BAA4B,KACf,SAAS,WAAW,EAAE,YAAY,WAAW,oCAiDzE"}

package/dist/src/handlers/workers/heartbeat.js

@@ -0,0 +1,42 @@
+/**
+ * POST /api/workers/[id]/heartbeat
+ *
+ * Send a heartbeat from a worker to keep registration active.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { updateHeartbeat, getWorker, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:workers:heartbeat');
+export function createWorkerHeartbeatHandler() {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: workerId } = await params;
+        try {
+            const body = await request.json();
+            const { activeCount, load } = body;
+            if (typeof activeCount !== 'number' || activeCount < 0) {
+                return NextResponse.json({ error: 'Bad Request', message: 'activeCount must be a non-negative number' }, { status: 400 });
+            }
+            const worker = await getWorker(workerId);
+            if (!worker) {
+                return NextResponse.json({ error: 'Not Found', message: 'Worker not found' }, { status: 404 });
+            }
+            const result = await updateHeartbeat(workerId, activeCount, load);
+            if (!result) {
+                return NextResponse.json({ error: 'Service Unavailable', message: 'Failed to update heartbeat' }, { status: 503 });
+            }
+            log.debug('Heartbeat received', {
+                workerId,
+                activeCount,
+                pendingWorkCount: result.pendingWorkCount,
+            });
+            return NextResponse.json(result);
+        }
+        catch (error) {
+            log.error('Failed to process heartbeat', { error, workerId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process heartbeat' }, { status: 500 });
+        }
+    };
+}