@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/middleware/factory.js

@@ -0,0 +1,185 @@
+/**
+ * Middleware Factory — Edge Runtime Compatible
+ *
+ * Creates a Next.js middleware function that handles authentication,
+ * rate limiting, and security for AgentFactory API routes.
+ *
+ * IMPORTANT: This module runs in the Edge Runtime. It MUST NOT import
+ * from @renseiai/agentfactory-server (which uses Node.js crypto/ioredis).
+ * All utilities are inlined for Edge compatibility.
+ */
+import { NextResponse } from 'next/server';
+const RATE_LIMITS = {
+    public: { limit: 60, windowMs: 60_000 },
+    webhook: { limit: 10, windowMs: 1_000 },
+    dashboard: { limit: 30, windowMs: 60_000 },
+};
+const caches = new Map();
+function checkRateLimit(type, key) {
+    const config = RATE_LIMITS[type];
+    let cache = caches.get(type);
+    if (!cache) {
+        cache = new Map();
+        caches.set(type, cache);
+    }
+    const now = Date.now();
+    const windowStart = now - config.windowMs;
+    let entry = cache.get(key);
+    if (!entry) {
+        entry = { timestamps: [], lastAccess: now };
+    }
+    entry.timestamps = entry.timestamps.filter((ts) => ts > windowStart);
+    entry.lastAccess = now;
+    const allowed = entry.timestamps.length < config.limit;
+    if (allowed)
+        entry.timestamps.push(now);
+    cache.set(key, entry);
+    // LRU eviction at 10k entries
+    if (cache.size > 10_000) {
+        const entries = Array.from(cache.entries()).sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+        const toRemove = Math.ceil(10_000 * 0.1);
+        for (let i = 0; i < toRemove && i < entries.length; i++) {
+            cache.delete(entries[i][0]);
+        }
+    }
+    const remaining = Math.max(0, config.limit - entry.timestamps.length);
+    const oldestTs = entry.timestamps[0];
+    const resetIn = oldestTs ? Math.max(0, oldestTs + config.windowMs - now) : 0;
+    return { allowed, remaining, resetIn, limit: config.limit };
+}
+// === Edge-compatible utilities ===
+function getClientIP(headers) {
+    return (headers.get('x-forwarded-for')?.split(',')[0].trim() ||
+        headers.get('cf-connecting-ip') ||
+        headers.get('x-real-ip') ||
+        'unknown');
+}
+function buildRateLimitHeaders(result) {
+    return {
+        'X-RateLimit-Limit': result.limit.toString(),
+        'X-RateLimit-Remaining': result.remaining.toString(),
+        'X-RateLimit-Reset': Math.ceil(result.resetIn / 1000).toString(),
+    };
+}
+/**
+ * Timing-safe string comparison using XOR (Edge-compatible).
+ * Does NOT use Node.js crypto.timingSafeEqual.
+ */
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+}
+// === Route defaults ===
+const DEFAULT_PUBLIC_ROUTES = ['/api/public/', '/dashboard', '/pipeline', '/settings', '/'];
+const DEFAULT_PROTECTED_ROUTES = ['/api/sessions', '/api/workers'];
+const DEFAULT_SESSION_PAGES = ['/sessions/'];
+const DEFAULT_WEBHOOK_ROUTE = '/webhook';
+const DEFAULT_PASSTHROUGH_ROUTES = ['/api/cleanup'];
+/**
+ * Create an AgentFactory middleware function with configurable routes
+ * and rate limiting.
+ *
+ * @example
+ * ```typescript
+ * // In middleware.ts:
+ * import { createAgentFactoryMiddleware } from '@renseiai/agentfactory-nextjs'
+ *
+ * const { middleware, matcherConfig } = createAgentFactoryMiddleware()
+ * export { middleware }
+ * export const config = matcherConfig
+ * ```
+ */
+export function createAgentFactoryMiddleware(userConfig) {
+    const publicRoutes = userConfig?.routes?.public ?? DEFAULT_PUBLIC_ROUTES;
+    const protectedRoutes = userConfig?.routes?.protected ?? DEFAULT_PROTECTED_ROUTES;
+    const sessionPages = userConfig?.routes?.sessionPages ?? DEFAULT_SESSION_PAGES;
+    const webhookRoute = userConfig?.routes?.webhook ?? DEFAULT_WEBHOOK_ROUTE;
+    const passthroughRoutes = userConfig?.routes?.passthrough ?? DEFAULT_PASSTHROUGH_ROUTES;
+    function middleware(request) {
+        const { pathname } = request.nextUrl;
+        const clientIP = getClientIP(request.headers);
+        // === PROTECTED INTERNAL APIS (checked first — no rate limiting) ===
+        // Must come before public routes because '/' in publicRoutes would
+        // match all pathnames via startsWith, rate-limiting authenticated workers.
+        if (protectedRoutes.some(route => pathname.startsWith(route))) {
+            const workerApiKey = process.env.WORKER_API_KEY;
+            // In development without key, allow access
+            if (!workerApiKey && process.env.NODE_ENV !== 'production') {
+                return NextResponse.next();
+            }
+            if (!workerApiKey) {
+                console.error('WORKER_API_KEY not configured - blocking protected API access');
+                return new NextResponse(JSON.stringify({ error: 'Unauthorized', message: 'Invalid or missing API key' }), { status: 401, headers: { 'Content-Type': 'application/json' } });
+            }
+            const authHeader = request.headers.get('authorization');
+            if (!authHeader?.startsWith('Bearer ')) {
+                return new NextResponse(JSON.stringify({ error: 'Unauthorized', message: 'Invalid or missing API key' }), { status: 401, headers: { 'Content-Type': 'application/json' } });
+            }
+            const token = authHeader.slice(7);
+            if (!timingSafeEqual(token, workerApiKey)) {
+                return new NextResponse(JSON.stringify({ error: 'Unauthorized', message: 'Invalid or missing API key' }), { status: 401, headers: { 'Content-Type': 'application/json' } });
+            }
+            return NextResponse.next();
+        }
+        // === WEBHOOK ROUTE ===
+        if (pathname === webhookRoute) {
+            const result = checkRateLimit('webhook', clientIP);
+            if (!result.allowed) {
+                return new NextResponse(JSON.stringify({ error: 'Too many requests' }), {
+                    status: 429,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...buildRateLimitHeaders(result),
+                    },
+                });
+            }
+            return NextResponse.next();
+        }
+        // === SESSION DETAIL PAGES ===
+        if (sessionPages.some(route => pathname.startsWith(route))) {
+            return NextResponse.next();
+        }
+        // === PASSTHROUGH ROUTES ===
+        if (passthroughRoutes.some(route => pathname === route || pathname.startsWith(route))) {
+            return NextResponse.next();
+        }
+        // === PUBLIC ROUTES (rate limited) ===
+        if (publicRoutes.some(route => pathname === route || pathname.startsWith(route))) {
+            const result = checkRateLimit('public', clientIP);
+            if (!result.allowed) {
+                return new NextResponse(JSON.stringify({ error: 'Too many requests' }), {
+                    status: 429,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...buildRateLimitHeaders(result),
+                    },
+                });
+            }
+            const response = NextResponse.next();
+            const rateLimitHeaders = buildRateLimitHeaders(result);
+            for (const [key, value] of Object.entries(rateLimitHeaders)) {
+                response.headers.set(key, value);
+            }
+            return response;
+        }
+        // === ALL OTHER ROUTES ===
+        return NextResponse.next();
+    }
+    const matcherConfig = {
+        matcher: [
+            '/api/:path*',
+            webhookRoute,
+            '/dashboard',
+            '/pipeline',
+            '/settings',
+            '/sessions/:path*',
+            '/',
+        ],
+    };
+    return { middleware, matcherConfig };
+}

package/dist/src/middleware/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Edge Runtime-safe middleware exports.
+ *
+ * This barrel ONLY re-exports modules that are compatible with Next.js
+ * Edge Runtime. It deliberately excludes worker-auth and cron-auth
+ * which depend on @renseiai/agentfactory-server (Node.js crypto/ioredis).
+ *
+ * Use this subpath import in middleware.ts:
+ *   import { createAgentFactoryMiddleware } from '@renseiai/agentfactory-nextjs/middleware'
+ *
+ * Do NOT import from the main barrel ('@renseiai/agentfactory-nextjs')
+ * in Edge Runtime — it pulls in Node.js-only modules.
+ */
+export { createAgentFactoryMiddleware } from './factory.js';
+export type { MiddlewareConfig } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/middleware/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAA;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA"}

package/dist/src/middleware/index.js

@@ -0,0 +1,14 @@
+/**
+ * Edge Runtime-safe middleware exports.
+ *
+ * This barrel ONLY re-exports modules that are compatible with Next.js
+ * Edge Runtime. It deliberately excludes worker-auth and cron-auth
+ * which depend on @renseiai/agentfactory-server (Node.js crypto/ioredis).
+ *
+ * Use this subpath import in middleware.ts:
+ *   import { createAgentFactoryMiddleware } from '@renseiai/agentfactory-nextjs/middleware'
+ *
+ * Do NOT import from the main barrel ('@renseiai/agentfactory-nextjs')
+ * in Edge Runtime — it pulls in Node.js-only modules.
+ */
+export { createAgentFactoryMiddleware } from './factory.js';

package/dist/src/middleware/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Types for the middleware factory.
+ */
+/**
+ * Configuration for the AgentFactory middleware.
+ */
+export interface MiddlewareConfig {
+    /** Route path configuration */
+    routes?: {
+        /** Public routes - no auth, with rate limiting (default: ['/api/public/', '/dashboard', '/']) */
+        public?: string[];
+        /** Protected routes - require WORKER_API_KEY (default: ['/api/sessions', '/api/workers']) */
+        protected?: string[];
+        /** Session detail pages - allow public access (default: ['/sessions/']) */
+        sessionPages?: string[];
+        /** Webhook route (default: '/webhook') */
+        webhook?: string;
+        /** Routes with custom auth in handler (default: ['/api/cleanup']) */
+        passthrough?: string[];
+    };
+    /** Rate limit configurations */
+    rateLimits?: {
+        /** Public endpoint rate limit (default: 60/min) */
+        public?: {
+            max: number;
+            windowMs: number;
+        };
+        /** Webhook endpoint rate limit (default: 10/sec) */
+        webhook?: {
+            max: number;
+            windowMs: number;
+        };
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/middleware/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/middleware/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,MAAM,CAAC,EAAE;QACP,iGAAiG;QACjG,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;QACjB,6FAA6F;QAC7F,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;QACpB,2EAA2E;QAC3E,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;QACvB,0CAA0C;QAC1C,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,qEAAqE;QACrE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KACvB,CAAA;IACD,gCAAgC;IAChC,UAAU,CAAC,EAAE;QACX,mDAAmD;QACnD,MAAM,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;QAC1C,oDAAoD;QACpD,OAAO,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAC5C,CAAA;CACF"}

package/dist/src/middleware/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the middleware factory.
+ */
+export {};

package/dist/src/middleware/worker-auth.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Worker Authentication — Next.js Adapter
+ *
+ * Thin wrapper around @renseiai/agentfactory-server's framework-agnostic
+ * auth functions, adapted for Next.js request/response types.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { isWorkerAuthConfigured } from '@renseiai/agentfactory-server';
+export { isWorkerAuthConfigured };
+/**
+ * Verify worker API key from request
+ */
+export declare function verifyWorkerAuth(request: NextRequest): boolean;
+/**
+ * Create an unauthorized response
+ */
+export declare function unauthorizedResponse(): NextResponse;
+/**
+ * Middleware helper for protected routes
+ *
+ * @param request - Next.js request object
+ * @returns NextResponse if unauthorized, null if authorized
+ */
+export declare function requireWorkerAuth(request: NextRequest): NextResponse | null;
+//# sourceMappingURL=worker-auth.d.ts.map

package/dist/src/middleware/worker-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-auth.d.ts","sourceRoot":"","sources":["../../../src/middleware/worker-auth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EAGL,sBAAsB,EAEvB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,sBAAsB,EAAE,CAAA;AAIjC;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAO9D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,YAAY,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI,CAS3E"}

package/dist/src/middleware/worker-auth.js

@@ -0,0 +1,43 @@
+/**
+ * Worker Authentication — Next.js Adapter
+ *
+ * Thin wrapper around @renseiai/agentfactory-server's framework-agnostic
+ * auth functions, adapted for Next.js request/response types.
+ */
+import { NextResponse } from 'next/server';
+import { extractBearerToken, verifyApiKey, isWorkerAuthConfigured, createLogger, } from '@renseiai/agentfactory-server';
+export { isWorkerAuthConfigured };
+const log = createLogger('worker-auth');
+/**
+ * Verify worker API key from request
+ */
+export function verifyWorkerAuth(request) {
+    const token = extractBearerToken(request.headers.get('authorization'));
+    if (!token) {
+        log.debug('Missing or invalid Authorization header');
+        return false;
+    }
+    return verifyApiKey(token);
+}
+/**
+ * Create an unauthorized response
+ */
+export function unauthorizedResponse() {
+    return NextResponse.json({ error: 'Unauthorized', message: 'Invalid or missing API key' }, { status: 401 });
+}
+/**
+ * Middleware helper for protected routes
+ *
+ * @param request - Next.js request object
+ * @returns NextResponse if unauthorized, null if authorized
+ */
+export function requireWorkerAuth(request) {
+    if (!verifyWorkerAuth(request)) {
+        log.warn('Unauthorized worker API request', {
+            path: request.nextUrl.pathname,
+            ip: request.headers.get('x-forwarded-for') || 'unknown',
+        });
+        return unauthorizedResponse();
+    }
+    return null;
+}

package/dist/src/orchestrator/error-formatting.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generic error formatting for Linear comments.
+ */
+/**
+ * Format an error for posting as a Linear comment with markdown.
+ */
+export declare function formatErrorForComment(error: Error): string;
+//# sourceMappingURL=error-formatting.d.ts.map

package/dist/src/orchestrator/error-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-formatting.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/error-formatting.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CA+B1D"}

package/dist/src/orchestrator/error-formatting.js

@@ -0,0 +1,35 @@
+/**
+ * Generic error formatting for Linear comments.
+ */
+import { AgentSpawnError } from '@renseiai/agentfactory-linear';
+/**
+ * Format an error for posting as a Linear comment with markdown.
+ */
+export function formatErrorForComment(error) {
+    const lines = ['## Agent Error', '', `**${error.name}**: ${error.message}`];
+    if (error instanceof AgentSpawnError) {
+        lines.push('');
+        lines.push(`- Issue ID: ${error.issueId}`);
+        if (error.sessionId) {
+            lines.push(`- Session ID: ${error.sessionId}`);
+        }
+        lines.push(`- Retryable: ${error.isRetryable ? 'Yes' : 'No'}`);
+        if (error.cause) {
+            lines.push(`- Cause: ${error.cause.message}`);
+        }
+    }
+    if (error.stack) {
+        lines.push('');
+        lines.push('<details>');
+        lines.push('<summary>Stack Trace</summary>');
+        lines.push('');
+        lines.push('```');
+        lines.push(error.stack);
+        lines.push('```');
+        lines.push('</details>');
+    }
+    lines.push('');
+    lines.push(`---`);
+    lines.push(`*Error occurred at ${new Date().toISOString()}*`);
+    return lines.join('\n');
+}

package/dist/src/orchestrator/index.d.ts

@@ -0,0 +1,4 @@
+export { createWebhookOrchestrator } from './webhook-orchestrator.js';
+export { formatErrorForComment } from './error-formatting.js';
+export type { WebhookOrchestratorConfig, WebhookOrchestratorHooks, WebhookOrchestratorInstance, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/orchestrator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAC7D,YAAY,EACV,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,YAAY,CAAA"}

package/dist/src/orchestrator/index.js

@@ -0,0 +1,2 @@
+export { createWebhookOrchestrator } from './webhook-orchestrator.js';
+export { formatErrorForComment } from './error-formatting.js';

package/dist/src/orchestrator/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Types for the webhook orchestrator factory.
+ */
+import type { AgentProcess, StopAgentResult, ForwardPromptResult } from '@renseiai/agentfactory';
+import type { RetryConfig } from '@renseiai/agentfactory-linear';
+/**
+ * Configuration for the webhook orchestrator.
+ */
+export interface WebhookOrchestratorConfig {
+    /** Maximum concurrent agents (default: 10) */
+    maxConcurrent?: number;
+    /** Enable auto-transition of Linear statuses (default: true) */
+    autoTransition?: boolean;
+    /** Retry configuration for agent spawning */
+    retryConfig?: Required<RetryConfig>;
+}
+/**
+ * Lifecycle hooks for agent events.
+ * Consumers use these to add custom behavior (e.g., marking agent-worked).
+ */
+export interface WebhookOrchestratorHooks {
+    /** Called when an agent starts successfully */
+    onAgentComplete?: (agent: AgentProcess) => Promise<void> | void;
+    /** Called when an agent fails with an error */
+    onAgentError?: (agent: AgentProcess, error: Error) => Promise<void> | void;
+    /** Called when an agent is stopped (e.g., by user) */
+    onAgentStopped?: (agent: AgentProcess) => void;
+}
+/**
+ * The webhook orchestrator instance provides methods to spawn, stop,
+ * and forward prompts to agents.
+ */
+export interface WebhookOrchestratorInstance {
+    /**
+     * Spawn an agent for an issue with idempotency and retry logic.
+     * Returns immediately after spawning — does not wait for completion.
+     */
+    spawnAgentAsync(issueId: string, sessionId: string, webhookId?: string): Promise<{
+        spawned: boolean;
+        reason?: string;
+        agent?: AgentProcess;
+        error?: Error;
+    }>;
+    /** Stop an agent by session ID */
+    stopAgentBySession(sessionId: string, cleanupWorktree?: boolean): Promise<StopAgentResult>;
+    /** Get an active agent by session ID */
+    getAgentBySession(sessionId: string): AgentProcess | undefined;
+    /** Check if an agent is already running for an issue */
+    isAgentRunningForIssue(issueId: string): boolean;
+    /** Forward a follow-up prompt to an existing or new agent */
+    forwardPromptAsync(issueId: string, sessionId: string, promptText: string): Promise<ForwardPromptResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/orchestrator/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAEhE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAA;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,+CAA+C;IAC/C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAC/D,+CAA+C;IAC/C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAC1E,sDAAsD;IACtD,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,eAAe,CACb,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,YAAY,CAAA;QACpB,KAAK,CAAC,EAAE,KAAK,CAAA;KACd,CAAC,CAAA;IAEF,kCAAkC;IAClC,kBAAkB,CAChB,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,OAAO,GACxB,OAAO,CAAC,eAAe,CAAC,CAAA;IAE3B,wCAAwC;IACxC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAAA;IAE9D,wDAAwD;IACxD,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAA;IAEhD,6DAA6D;IAC7D,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,mBAAmB,CAAC,CAAA;CAChC"}

package/dist/src/orchestrator/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the webhook orchestrator factory.
+ */
+export {};

package/dist/src/orchestrator/webhook-orchestrator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Webhook Orchestrator Factory
+ *
+ * Creates a singleton orchestrator instance configured for webhook-triggered
+ * agent spawning. Includes retry logic, idempotency, session state persistence,
+ * and error activity emission to Linear.
+ *
+ * Consumers provide lifecycle hooks (e.g., onAgentComplete) for custom behavior
+ * like marking issues as "agent-worked" for automated QA.
+ */
+import type { WebhookOrchestratorConfig, WebhookOrchestratorHooks, WebhookOrchestratorInstance } from './types.js';
+/**
+ * Create a webhook orchestrator instance.
+ *
+ * @param config - Orchestrator configuration
+ * @param hooks - Lifecycle hooks for custom behavior
+ * @returns A webhook orchestrator instance
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createWebhookOrchestrator(
+ *   { maxConcurrent: 10 },
+ *   {
+ *     onAgentComplete: async (agent) => {
+ *       await markAgentWorked(agent.issueId, { ... })
+ *     },
+ *   }
+ * )
+ * ```
+ */
+export declare function createWebhookOrchestrator(config?: WebhookOrchestratorConfig, hooks?: WebhookOrchestratorHooks): WebhookOrchestratorInstance;
+//# sourceMappingURL=webhook-orchestrator.d.ts.map

package/dist/src/orchestrator/webhook-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-orchestrator.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/webhook-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAqCH,OAAO,KAAK,EACV,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,YAAY,CAAA;AAyFnB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,CAAC,EAAE,yBAAyB,EAClC,KAAK,CAAC,EAAE,wBAAwB,GAC/B,2BAA2B,CAsT7B"}