@supaku/agentfactory-nextjs 0.3.0

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

@@ -0,0 +1,82 @@
+/**
+ * POST /api/sessions/[id]/progress
+ *
+ * Post a progress update as an agent activity to Linear.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@supaku/agentfactory-server';
+const log = createLogger('api:sessions:progress');
+const MILESTONE_EMOJI = {
+    claimed: '\u{1f527}',
+    worktree: '\u{1f4c2}',
+    started: '\u{1f916}',
+    running: '\u23f3',
+    tests: '\u{1f9ea}',
+    pr: '\u{1f500}',
+    completed: '\u2705',
+    failed: '\u274c',
+    stopped: '\u{1f6d1}',
+    resumed: '\u{1f504}',
+};
+export function createSessionProgressHandler(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, milestone, message } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            if (!message || typeof message !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'message 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 });
+            }
+            const emoji = milestone ? MILESTONE_EMOJI[milestone] || '\u2139\ufe0f' : '';
+            const formattedMessage = emoji ? `${emoji} ${message}` : message;
+            try {
+                const linearClient = await config.linearClient.getClient(session.organizationId);
+                await linearClient.createAgentActivity({
+                    agentSessionId: session.linearSessionId,
+                    content: { type: 'response', body: formattedMessage },
+                    ephemeral: false,
+                });
+                log.info('Progress activity posted', {
+                    sessionId,
+                    linearSessionId: session.linearSessionId,
+                    milestone,
+                    messageLength: message.length,
+                });
+                return NextResponse.json({
+                    posted: true,
+                    milestone,
+                });
+            }
+            catch (linearError) {
+                log.error('Failed to post progress activity to Linear', {
+                    error: linearError,
+                    sessionId,
+                    linearSessionId: session.linearSessionId,
+                    milestone,
+                });
+                return NextResponse.json({
+                    posted: false,
+                    reason: 'Failed to post to Linear',
+                });
+            }
+        }
+        catch (error) {
+            log.error('Failed to process progress update', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process progress update' }, { status: 500 });
+        }
+    };
+}

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 '@supaku/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,18 @@
+/**
+ * GET, POST /api/sessions/[id]/status
+ *
+ * Report status update from worker or get current status.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionStatusPostHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export declare function createSessionStatusGetHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<import("@supaku/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;AAkBvD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAYD,wBAAgB,8BAA8B,KACjB,SAAS,WAAW,EAAE,YAAY,WAAW,oCA4HzE;AAED,wBAAgB,6BAA6B,KACjB,SAAS,WAAW,EAAE,YAAY,WAAW;;;4EAsBxE"}

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

@@ -0,0 +1,131 @@
+/**
+ * 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, updateClaudeSessionId, startSession, removeWorkerSession, releaseClaim, markAgentWorked, releaseIssueLock, promoteNextPendingWork, createLogger, } from '@supaku/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() {
+    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, claudeSessionId, worktreePath, error: errorInfo } = 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 (claudeSessionId) {
+                    await updateClaudeSessionId(sessionId, claudeSessionId);
+                }
+            }
+            else if (status === 'finalizing') {
+                await updateSessionStatus(sessionId, 'finalizing');
+            }
+            else if (TERMINAL_STATUSES.includes(status)) {
+                await updateSessionStatus(sessionId, status);
+                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 });
+                    }
+                }
+                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,
+                hasClaudeSessionId: !!claudeSessionId,
+                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,oCA+GzE"}

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

@@ -0,0 +1,91 @@
+/**
+ * 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 '@supaku/agentfactory-server';
+import { createAgentSession, ENVIRONMENT_ISSUE_TYPES } from '@supaku/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 });
+            }
+            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) {
+                log.error('Failed to report tool error to Linear', {
+                    error: linearError,
+                    sessionId,
+                    toolName,
+                });
+                return NextResponse.json({
+                    created: false,
+                    reason: 'Failed to report to Linear',
+                });
+            }
+        }
+        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 '@supaku/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 '@supaku/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"}