@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/factory.js

@@ -0,0 +1,127 @@
+/**
+ * Factory — @renseiai/agentfactory-nextjs
+ *
+ * Wires all handlers together from a single configuration object.
+ * Consumers call `createAllRoutes(config)` and get back a nested
+ * route tree that maps 1:1 onto Next.js App Router exports.
+ *
+ * When optional config fields are omitted, sensible defaults from
+ * @renseiai/agentfactory-linear are used (defaultGeneratePrompt, etc.).
+ */
+import { defaultGeneratePrompt, defaultDetectWorkTypeFromPrompt, defaultGetPriority, defaultBuildParentQAContext, defaultBuildParentAcceptanceContext, } from '@renseiai/agentfactory-linear';
+// Worker handlers
+import { createWorkerRegisterHandler } from './handlers/workers/register.js';
+import { createWorkerListHandler } from './handlers/workers/list.js';
+import { createWorkerGetHandler, createWorkerDeleteHandler } from './handlers/workers/get-delete.js';
+import { createWorkerHeartbeatHandler } from './handlers/workers/heartbeat.js';
+import { createWorkerPollHandler } from './handlers/workers/poll.js';
+// Session handlers (no Linear)
+import { createSessionListHandler } from './handlers/sessions/list.js';
+import { createSessionGetHandler } from './handlers/sessions/get.js';
+import { createSessionClaimHandler } from './handlers/sessions/claim.js';
+import { createSessionStatusPostHandler, createSessionStatusGetHandler } from './handlers/sessions/status.js';
+import { createSessionLockRefreshHandler } from './handlers/sessions/lock-refresh.js';
+import { createSessionPromptsGetHandler, createSessionPromptsPostHandler } from './handlers/sessions/prompts.js';
+import { createSessionTransferOwnershipHandler } from './handlers/sessions/transfer-ownership.js';
+// Session handlers (Linear forwarding)
+import { createSessionActivityHandler } from './handlers/sessions/activity.js';
+import { createSessionCompletionHandler } from './handlers/sessions/completion.js';
+import { createSessionExternalUrlsHandler } from './handlers/sessions/external-urls.js';
+import { createSessionProgressHandler } from './handlers/sessions/progress.js';
+import { createSessionToolErrorHandler } from './handlers/sessions/tool-error.js';
+// Public handlers
+import { createPublicStatsHandler } from './handlers/public/stats.js';
+import { createPublicSessionsListHandler } from './handlers/public/sessions-list.js';
+import { createPublicSessionDetailHandler } from './handlers/public/session-detail.js';
+// Cleanup handler
+import { createCleanupHandler } from './handlers/cleanup.js';
+// Config handler
+import { createConfigHandler } from './handlers/config.js';
+// Webhook processor
+import { createWebhookHandler } from './webhook/processor.js';
+// OAuth handler
+import { createOAuthCallbackHandler } from './handlers/oauth/callback.js';
+// Issue tracker proxy handler
+import { createIssueTrackerProxyHandler } from './handlers/issue-tracker-proxy/index.js';
+/**
+ * Create all route handlers from a single config object.
+ *
+ * Optional fields fall back to sensible defaults from @renseiai/agentfactory-linear:
+ * - `generatePrompt` → `defaultGeneratePrompt`
+ * - `detectWorkTypeFromPrompt` → `defaultDetectWorkTypeFromPrompt`
+ * - `getPriority` → `defaultGetPriority`
+ * - `buildParentQAContext` → `defaultBuildParentQAContext`
+ * - `buildParentAcceptanceContext` → `defaultBuildParentAcceptanceContext`
+ *
+ * @example
+ * ```typescript
+ * import { createAllRoutes, createDefaultLinearClientResolver } from '@renseiai/agentfactory-nextjs'
+ *
+ * // Minimal — everything uses defaults
+ * const routes = createAllRoutes({
+ *   linearClient: createDefaultLinearClientResolver(),
+ * })
+ *
+ * // Custom — override specific callbacks
+ * const routes = createAllRoutes({
+ *   linearClient: createDefaultLinearClientResolver(),
+ *   generatePrompt: myCustomPromptFn,
+ *   oauth: { clientId: '...', clientSecret: '...' },
+ * })
+ * ```
+ */
+export function createAllRoutes(config) {
+    // Apply defaults for optional webhook config fields
+    const webhookConfig = {
+        ...config,
+        generatePrompt: config.generatePrompt ?? defaultGeneratePrompt,
+        detectWorkTypeFromPrompt: config.detectWorkTypeFromPrompt ?? defaultDetectWorkTypeFromPrompt,
+        getPriority: config.getPriority ?? defaultGetPriority,
+        buildParentQAContext: config.buildParentQAContext ?? defaultBuildParentQAContext,
+        buildParentAcceptanceContext: config.buildParentAcceptanceContext ?? defaultBuildParentAcceptanceContext,
+    };
+    const routeConfig = {
+        linearClient: config.linearClient,
+        appUrl: config.appUrl,
+    };
+    const cleanup = createCleanupHandler(webhookConfig);
+    const webhook = createWebhookHandler(webhookConfig);
+    const oauth = createOAuthCallbackHandler(config.oauth);
+    const configHandler = createConfigHandler(config.projects);
+    const issueTrackerProxy = createIssueTrackerProxyHandler(routeConfig);
+    return {
+        workers: {
+            register: { POST: createWorkerRegisterHandler() },
+            list: { GET: createWorkerListHandler() },
+            detail: { GET: createWorkerGetHandler(), DELETE: createWorkerDeleteHandler() },
+            heartbeat: { POST: createWorkerHeartbeatHandler() },
+            poll: { GET: createWorkerPollHandler() },
+        },
+        sessions: {
+            list: { GET: createSessionListHandler() },
+            detail: { GET: createSessionGetHandler() },
+            claim: { POST: createSessionClaimHandler() },
+            status: { GET: createSessionStatusGetHandler(), POST: createSessionStatusPostHandler(routeConfig) },
+            lockRefresh: { POST: createSessionLockRefreshHandler() },
+            prompts: { GET: createSessionPromptsGetHandler(), POST: createSessionPromptsPostHandler() },
+            transferOwnership: { POST: createSessionTransferOwnershipHandler() },
+            activity: { POST: createSessionActivityHandler(routeConfig) },
+            completion: { POST: createSessionCompletionHandler(routeConfig) },
+            externalUrls: { POST: createSessionExternalUrlsHandler(routeConfig) },
+            progress: { POST: createSessionProgressHandler(routeConfig) },
+            toolError: { POST: createSessionToolErrorHandler(routeConfig) },
+        },
+        public: {
+            stats: { GET: createPublicStatsHandler() },
+            sessions: { GET: createPublicSessionsListHandler() },
+            sessionDetail: { GET: createPublicSessionDetailHandler() },
+        },
+        config: { GET: configHandler.GET },
+        cleanup: { POST: cleanup.POST, GET: cleanup.GET },
+        webhook: { POST: webhook.POST, GET: webhook.GET },
+        oauth: {
+            callback: { GET: oauth.GET },
+        },
+        issueTrackerProxy: { POST: issueTrackerProxy.POST, GET: issueTrackerProxy.GET },
+    };
+}

package/dist/src/handlers/cleanup.d.ts

@@ -0,0 +1,44 @@
+/**
+ * POST, GET /api/cleanup
+ *
+ * Trigger orphan session cleanup.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { CronConfig } from '../types.js';
+export declare function createCleanupHandler(config?: CronConfig): {
+    POST: (request: NextRequest) => Promise<NextResponse<{
+        checked: number;
+        orphaned: number;
+        requeued: number;
+        failed: number;
+        details: Array<{
+            sessionId: string;
+            issueIdentifier: string;
+            action: "requeued" | "failed";
+            reason?: string;
+            worktreePath?: string;
+        }>;
+        worktreePathsToCleanup: string[];
+        success: boolean;
+    }> | NextResponse<{
+        error: string;
+    }>>;
+    GET: (request: NextRequest) => Promise<NextResponse<{
+        checked: number;
+        orphaned: number;
+        requeued: number;
+        failed: number;
+        details: Array<{
+            sessionId: string;
+            issueIdentifier: string;
+            action: "requeued" | "failed";
+            reason?: string;
+            worktreePath?: string;
+        }>;
+        worktreePathsToCleanup: string[];
+        success: boolean;
+    }> | NextResponse<{
+        error: string;
+    }>>;
+};
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/src/handlers/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../src/handlers/cleanup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,UAAU;oBAChB,WAAW;;;;;;;;;kBAgC4e,CAAC;wBAAkG,CAAC;;;;;;;mBAhC3lB,WAAW;;;;;;;;;kBAgC4e,CAAC;wBAAkG,CAAC;;;;;;;EADloB"}

package/dist/src/handlers/cleanup.js

@@ -0,0 +1,34 @@
+/**
+ * POST, GET /api/cleanup
+ *
+ * Trigger orphan session cleanup.
+ */
+import { NextResponse } from 'next/server';
+import { cleanupOrphanedSessions, createLogger } from '@renseiai/agentfactory-server';
+import { verifyCronAuth } from '../middleware/cron-auth.js';
+const log = createLogger('api:cleanup');
+export function createCleanupHandler(config) {
+    async function handleCleanup(request) {
+        const authResult = verifyCronAuth(request, config?.cronSecret);
+        if (!authResult.authorized) {
+            log.warn('Unauthorized cleanup request', { reason: authResult.reason });
+            return NextResponse.json({ error: 'Unauthorized', message: authResult.reason }, { status: 401 });
+        }
+        try {
+            log.info('Running orphan cleanup');
+            const result = await cleanupOrphanedSessions();
+            return NextResponse.json({
+                success: true,
+                ...result,
+            });
+        }
+        catch (error) {
+            log.error('Cleanup failed', { error });
+            return NextResponse.json({ error: 'Cleanup failed' }, { status: 500 });
+        }
+    }
+    return {
+        POST: handleCleanup,
+        GET: handleCleanup,
+    };
+}

package/dist/src/handlers/config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Config endpoint — exposes server configuration to workers.
+ *
+ * Workers query this during registration to auto-inherit project scope
+ * when not explicitly configured via --projects flag.
+ */
+import type { RouteHandler } from '../types.js';
+export declare function createConfigHandler(projects?: string[]): {
+    GET: RouteHandler;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/src/handlers/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/handlers/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG;IAAE,GAAG,EAAE,YAAY,CAAA;CAAE,CAW9E"}

package/dist/src/handlers/config.js

@@ -0,0 +1,20 @@
+/**
+ * Config endpoint — exposes server configuration to workers.
+ *
+ * Workers query this during registration to auto-inherit project scope
+ * when not explicitly configured via --projects flag.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../middleware/worker-auth.js';
+export function createConfigHandler(projects) {
+    return {
+        GET: async (request) => {
+            const authError = requireWorkerAuth(request);
+            if (authError)
+                return authError;
+            return NextResponse.json({
+                projects: projects ?? [],
+            });
+        },
+    };
+}

package/dist/src/handlers/issue-tracker-proxy/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Issue Tracker Proxy Handler
+ *
+ * Centralizes all issue tracker API calls through the dashboard server.
+ * Agents, governors, and CLI tools call this endpoint instead of the
+ * issue tracker (e.g., Linear) directly.
+ *
+ * Benefits:
+ * - Single rate limiter and circuit breaker for all consumers
+ * - OAuth token management stays server-side
+ * - Response caching (future: Redis-based read-through cache)
+ * - Platform-agnostic interface: consumers don't need to know Linear exists
+ *
+ * POST /api/issue-tracker-proxy
+ * Body: { method: string, args: unknown[], organizationId?: string }
+ * Auth: Bearer <worker-api-key>
+ *
+ * GET /api/issue-tracker-proxy/health
+ * Returns: circuit breaker state, rate limiter tokens, quota remaining
+ */
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import type { ProxyHandlerConfig } from './types.js';
+/**
+ * Create the issue tracker proxy handler.
+ *
+ * @param config - Route config with Linear client resolver
+ * @returns POST handler for proxy requests, GET handler for health check
+ */
+export declare function createIssueTrackerProxyHandler(config: ProxyHandlerConfig): {
+    POST: (request: NextRequest) => Promise<NextResponse>;
+    GET: (_request: NextRequest) => Promise<NextResponse>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/handlers/issue-tracker-proxy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/handlers/issue-tracker-proxy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAU9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAiDpD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,kBAAkB;oBAC1C,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;oBAgJnC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;EAwBjE"}

package/dist/src/handlers/issue-tracker-proxy/index.js

@@ -0,0 +1,230 @@
+/**
+ * Issue Tracker Proxy Handler
+ *
+ * Centralizes all issue tracker API calls through the dashboard server.
+ * Agents, governors, and CLI tools call this endpoint instead of the
+ * issue tracker (e.g., Linear) directly.
+ *
+ * Benefits:
+ * - Single rate limiter and circuit breaker for all consumers
+ * - OAuth token management stays server-side
+ * - Response caching (future: Redis-based read-through cache)
+ * - Platform-agnostic interface: consumers don't need to know Linear exists
+ *
+ * POST /api/issue-tracker-proxy
+ * Body: { method: string, args: unknown[], organizationId?: string }
+ * Auth: Bearer <worker-api-key>
+ *
+ * GET /api/issue-tracker-proxy/health
+ * Returns: circuit breaker state, rate limiter tokens, quota remaining
+ */
+import { NextResponse } from 'next/server';
+import { createLogger } from '@renseiai/agentfactory-server';
+import { isCircuitOpenError } from '@renseiai/agentfactory-linear';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { serializeIssue, serializeComment, serializeViewer, serializeTeam } from './serializer.js';
+const log = createLogger('api:issue-tracker-proxy');
+/** Methods that are allowed through the proxy */
+const ALLOWED_METHODS = new Set([
+    'getIssue',
+    'updateIssue',
+    'createIssue',
+    'createComment',
+    'getIssueComments',
+    'getTeamStatuses',
+    'updateIssueStatus',
+    'createAgentActivity',
+    'updateAgentSession',
+    'createAgentSessionOnIssue',
+    'createIssueRelation',
+    'getIssueRelations',
+    'deleteIssueRelation',
+    'getSubIssues',
+    'getSubIssueStatuses',
+    'getSubIssueGraph',
+    'isParentIssue',
+    'isChildIssue',
+    'listProjectIssues',
+    'getProjectRepositoryUrl',
+    'getViewer',
+    'getTeam',
+    'unassignIssue',
+]);
+/**
+ * Methods that return Issue objects needing serialization.
+ */
+const ISSUE_RETURNING_METHODS = new Set([
+    'getIssue',
+    'updateIssue',
+    'createIssue',
+    'updateIssueStatus',
+    'unassignIssue',
+]);
+/**
+ * Methods that return Comment objects needing serialization.
+ */
+const COMMENT_RETURNING_METHODS = new Set([
+    'createComment',
+]);
+/**
+ * Create the issue tracker proxy handler.
+ *
+ * @param config - Route config with Linear client resolver
+ * @returns POST handler for proxy requests, GET handler for health check
+ */
+export function createIssueTrackerProxyHandler(config) {
+    async function POST(request) {
+        // Authenticate caller
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return NextResponse.json({ success: false, error: { code: 'INVALID_JSON', message: 'Invalid JSON body', retryable: false } }, { status: 400 });
+        }
+        const { method, args, organizationId } = body;
+        // Validate method
+        if (!method || !ALLOWED_METHODS.has(method)) {
+            return NextResponse.json({ success: false, error: { code: 'INVALID_METHOD', message: `Unknown method: ${method}`, retryable: false } }, { status: 400 });
+        }
+        // Validate args
+        if (!Array.isArray(args)) {
+            return NextResponse.json({ success: false, error: { code: 'INVALID_ARGS', message: 'args must be an array', retryable: false } }, { status: 400 });
+        }
+        log.debug('Proxy request', { method, organizationId, argsLength: args.length });
+        try {
+            // Resolve the Linear client for this workspace
+            const client = await config.linearClient.getClient(organizationId);
+            // Call the method on the client
+            const fn = client[method];
+            if (typeof fn !== 'function') {
+                return NextResponse.json({ success: false, error: { code: 'METHOD_NOT_FOUND', message: `Method ${method} not available on client`, retryable: false } }, { status: 400 });
+            }
+            const rawResult = await fn.apply(client, args);
+            // Serialize result based on method type.
+            // The serializer functions use duck-typing (no @linear/sdk dependency).
+            let data;
+            if (ISSUE_RETURNING_METHODS.has(method) && rawResult && typeof rawResult === 'object' && 'id' in rawResult) {
+                data = await serializeIssue(rawResult);
+            }
+            else if (COMMENT_RETURNING_METHODS.has(method) && rawResult && typeof rawResult === 'object' && 'body' in rawResult) {
+                data = await serializeComment(rawResult);
+            }
+            else if (method === 'getIssueComments' && Array.isArray(rawResult)) {
+                data = await Promise.all(rawResult.map((c) => serializeComment(c)));
+            }
+            else if (method === 'getSubIssues' && Array.isArray(rawResult)) {
+                data = await Promise.all(rawResult.map((i) => serializeIssue(i)));
+            }
+            else if (method === 'getViewer' && rawResult && typeof rawResult === 'object' && 'email' in rawResult) {
+                data = serializeViewer(rawResult);
+            }
+            else if (method === 'getTeam' && rawResult && typeof rawResult === 'object' && 'key' in rawResult) {
+                data = serializeTeam(rawResult);
+            }
+            else {
+                // Plain JSON-serializable results (e.g., boolean, relation results, status maps, sub-issue statuses, graphs)
+                data = rawResult;
+            }
+            const response = { success: true, data };
+            return NextResponse.json(response);
+        }
+        catch (error) {
+            // Circuit breaker open — return 503 so callers know to retry later
+            if (isCircuitOpenError(error)) {
+                log.warn('Proxy request blocked by circuit breaker', { method });
+                return NextResponse.json({
+                    success: false,
+                    error: {
+                        code: 'CIRCUIT_OPEN',
+                        message: error.message,
+                        retryable: true,
+                    },
+                }, {
+                    status: 503,
+                    headers: { 'Retry-After': String(Math.ceil(error.retryAfterMs / 1000)) },
+                });
+            }
+            // Auth errors — return 401/403
+            const statusCode = extractStatusCode(error);
+            if (statusCode === 401 || statusCode === 403) {
+                log.error('Proxy auth error', { method, statusCode });
+                return NextResponse.json({
+                    success: false,
+                    error: {
+                        code: 'AUTH_ERROR',
+                        message: error instanceof Error ? error.message : 'Authentication failed',
+                        retryable: false,
+                    },
+                }, { status: statusCode });
+            }
+            // Rate limited
+            if (statusCode === 429) {
+                log.warn('Proxy rate limited by upstream', { method });
+                return NextResponse.json({
+                    success: false,
+                    error: {
+                        code: 'RATE_LIMITED',
+                        message: 'Rate limited by upstream issue tracker',
+                        retryable: true,
+                    },
+                }, { status: 429, headers: { 'Retry-After': '60' } });
+            }
+            // Generic errors
+            log.error('Proxy request failed', {
+                method,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return NextResponse.json({
+                success: false,
+                error: {
+                    code: 'PROXY_ERROR',
+                    message: error instanceof Error ? error.message : 'Proxy request failed',
+                    retryable: statusCode !== undefined && statusCode >= 500,
+                },
+            }, { status: statusCode ?? 500 });
+        }
+    }
+    async function GET(_request) {
+        // Health endpoint — no auth required for monitoring
+        try {
+            const { getQuota } = await import('@renseiai/agentfactory-server');
+            const quota = await getQuota('default');
+            return NextResponse.json({
+                healthy: true,
+                quota: {
+                    requestsRemaining: quota.requestsRemaining,
+                    complexityRemaining: quota.complexityRemaining,
+                    resetAt: quota.requestsReset,
+                    updatedAt: quota.updatedAt,
+                },
+            });
+        }
+        catch {
+            return NextResponse.json({
+                healthy: true,
+                quota: { requestsRemaining: null, complexityRemaining: null, resetAt: null, updatedAt: 0 },
+            });
+        }
+    }
+    return { POST, GET };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extractStatusCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const err = error;
+    if (typeof err.status === 'number')
+        return err.status;
+    if (typeof err.statusCode === 'number')
+        return err.statusCode;
+    const response = err.response;
+    if (response && typeof response.status === 'number')
+        return response.status;
+    return undefined;
+}

package/dist/src/handlers/issue-tracker-proxy/serializer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Linear SDK Object Serializer
+ *
+ * The @linear/sdk returns objects with lazy-loaded relations (e.g., issue.state
+ * is a Promise). The proxy must resolve these server-side and return plain JSON.
+ *
+ * Uses duck-typing rather than direct @linear/sdk imports since the nextjs
+ * package doesn't depend on @linear/sdk directly.
+ */
+import type { SerializedIssue, SerializedComment, SerializedViewer, SerializedTeam } from '@renseiai/agentfactory-linear';
+/**
+ * Serialize a Linear Issue object to plain JSON.
+ * Resolves state, labels, assignee, team, parent, and project relations.
+ */
+export declare function serializeIssue(issue: unknown): Promise<SerializedIssue>;
+/**
+ * Serialize a Linear Comment object to plain JSON.
+ */
+export declare function serializeComment(comment: unknown): Promise<SerializedComment>;
+/**
+ * Serialize a Linear viewer to plain JSON.
+ */
+export declare function serializeViewer(viewer: unknown): SerializedViewer;
+/**
+ * Serialize a Linear team to plain JSON.
+ */
+export declare function serializeTeam(team: unknown): SerializedTeam;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/src/handlers/issue-tracker-proxy/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../src/handlers/issue-tracker-proxy/serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACf,MAAM,+BAA+B,CAAA;AA6CtC;;;GAGG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,CAqC7E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAWnF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAOjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,CAO3D"}

package/dist/src/handlers/issue-tracker-proxy/serializer.js

@@ -0,0 +1,95 @@
+/**
+ * Linear SDK Object Serializer
+ *
+ * The @linear/sdk returns objects with lazy-loaded relations (e.g., issue.state
+ * is a Promise). The proxy must resolve these server-side and return plain JSON.
+ *
+ * Uses duck-typing rather than direct @linear/sdk imports since the nextjs
+ * package doesn't depend on @linear/sdk directly.
+ */
+/**
+ * Safe promise resolve — catches errors and returns fallback.
+ */
+async function safeResolve(p, fallback) {
+    if (!p)
+        return fallback;
+    try {
+        return await p;
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Serialize a Linear Issue object to plain JSON.
+ * Resolves state, labels, assignee, team, parent, and project relations.
+ */
+export async function serializeIssue(issue) {
+    const i = issue;
+    const [state, labels, assignee, team, parent, project] = await Promise.all([
+        safeResolve(i.state, null),
+        safeResolve(i.labels?.().then((r) => r.nodes), []),
+        safeResolve(i.assignee, null),
+        safeResolve(i.team, null),
+        safeResolve(i.parent, null),
+        safeResolve(i.project, null),
+    ]);
+    return {
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        description: i.description ?? undefined,
+        url: i.url,
+        priority: i.priority,
+        state: state
+            ? { id: state.id, name: state.name, type: state.type }
+            : undefined,
+        labels: (labels ?? []).map((l) => ({ id: l.id, name: l.name })),
+        assignee: assignee
+            ? { id: assignee.id, name: assignee.name, email: assignee.email ?? undefined }
+            : null,
+        team: team ? { id: team.id, name: team.name, key: team.key } : undefined,
+        parent: parent
+            ? { id: parent.id, identifier: parent.identifier }
+            : null,
+        project: project ? { id: project.id, name: project.name } : null,
+        createdAt: i.createdAt.toISOString(),
+        updatedAt: i.updatedAt.toISOString(),
+    };
+}
+/**
+ * Serialize a Linear Comment object to plain JSON.
+ */
+export async function serializeComment(comment) {
+    const c = comment;
+    const user = await safeResolve(c.user, null);
+    return {
+        id: c.id,
+        body: c.body,
+        createdAt: c.createdAt.toISOString(),
+        updatedAt: c.updatedAt.toISOString(),
+        user: user ? { id: user.id, name: user.name } : null,
+    };
+}
+/**
+ * Serialize a Linear viewer to plain JSON.
+ */
+export function serializeViewer(viewer) {
+    const v = viewer;
+    return {
+        id: v.id,
+        name: v.name,
+        email: v.email,
+    };
+}
+/**
+ * Serialize a Linear team to plain JSON.
+ */
+export function serializeTeam(team) {
+    const t = team;
+    return {
+        id: t.id,
+        name: t.name,
+        key: t.key,
+    };
+}

package/dist/src/handlers/issue-tracker-proxy/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Types for the issue tracker proxy handler.
+ */
+import type { RouteConfig } from '../../types.js';
+export interface ProxyHandlerConfig extends RouteConfig {
+    /** Optional: override worker API key env var (default: WORKER_API_KEY) */
+    workerApiKeyEnvVar?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/handlers/issue-tracker-proxy/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/handlers/issue-tracker-proxy/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B"}

package/dist/src/handlers/issue-tracker-proxy/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the issue tracker proxy handler.
+ */
+export {};