@wolpertingerlabs/drawlatch 1.0.0-alpha.1

package/dist/remote/ingestors/manager.js

@@ -0,0 +1,201 @@
+/**
+ * IngestorManager — owns and manages the lifecycle of all ingestor instances.
+ *
+ * Keyed by `callerAlias:connectionAlias`, so each caller gets its own
+ * ingestor instance (with its own secrets, buffer, and connection state).
+ * Multiple sessions from the same caller share the same ingestor/buffer.
+ *
+ * The manager is created once when the remote server starts, and provides
+ * event retrieval and status methods used by the `poll_events` and
+ * `ingestor_status` tool handlers.
+ */
+import { resolveCallerRoutes, resolveRoutes, resolveSecrets, } from '../../shared/config.js';
+import { createLogger } from '../../shared/logger.js';
+const log = createLogger('ingestor');
+import { createIngestor } from './registry.js';
+import { WebhookIngestor } from './webhook/base-webhook-ingestor.js';
+// Import providers so they self-register their factories.
+// Each provider calls registerIngestorFactory() at module load time.
+import './discord/discord-gateway.js';
+import './slack/socket-mode.js';
+import './webhook/github-webhook-ingestor.js';
+import './webhook/stripe-webhook-ingestor.js';
+import './webhook/trello-webhook-ingestor.js';
+import './poll/poll-ingestor.js';
+export class IngestorManager {
+    config;
+    /** Active ingestor instances, keyed by `callerAlias:connectionAlias`. */
+    ingestors = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Start ingestors for all callers whose connections have an `ingestor` config.
+     * Called once when the remote server starts listening.
+     */
+    async startAll() {
+        for (const [callerAlias, callerConfig] of Object.entries(this.config.callers)) {
+            // Resolve routes for this caller (raw + resolved)
+            const rawRoutes = resolveCallerRoutes(this.config, callerAlias);
+            const callerEnvResolved = resolveSecrets(callerConfig.env ?? {});
+            const resolvedRoutes = resolveRoutes(rawRoutes, callerEnvResolved);
+            for (let i = 0; i < rawRoutes.length; i++) {
+                const rawRoute = rawRoutes[i];
+                const resolvedRoute = resolvedRoutes[i];
+                const connectionAlias = callerConfig.connections[i];
+                // Skip connections without an ingestor config
+                if (!rawRoute.ingestor)
+                    continue;
+                // Get caller-level overrides for this connection
+                const overrides = callerConfig.ingestorOverrides?.[connectionAlias];
+                // Skip if explicitly disabled by caller
+                if (overrides?.disabled) {
+                    log.info(`Skipping disabled ingestor for ${callerAlias}:${connectionAlias}`);
+                    continue;
+                }
+                const key = `${callerAlias}:${connectionAlias}`;
+                if (this.ingestors.has(key))
+                    continue;
+                // Merge caller overrides into a copy of the template config
+                const effectiveConfig = IngestorManager.mergeIngestorConfig(rawRoute.ingestor, overrides);
+                // For poll ingestors, attach the resolved route headers so the factory
+                // can pass them through for authenticated HTTP requests.
+                if (effectiveConfig.type === 'poll') {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any -- private property consumed by poll factory
+                    effectiveConfig._resolvedRouteHeaders = resolvedRoute.headers;
+                }
+                const ingestor = createIngestor(connectionAlias, effectiveConfig, resolvedRoute.secrets, overrides?.bufferSize);
+                if (ingestor) {
+                    this.ingestors.set(key, ingestor);
+                    log.info(`Starting ${effectiveConfig.type} ingestor for ${key}`);
+                    try {
+                        await ingestor.start();
+                    }
+                    catch (err) {
+                        log.error(`Failed to start ${key}:`, err);
+                    }
+                }
+            }
+        }
+        const count = this.ingestors.size;
+        if (count > 0) {
+            log.info(`${count} ingestor(s) started`);
+        }
+    }
+    /**
+     * Stop all running ingestors. Called during graceful shutdown.
+     */
+    async stopAll() {
+        const stops = Array.from(this.ingestors.entries()).map(async ([key, ingestor]) => {
+            log.info(`Stopping ${key}`);
+            try {
+                await ingestor.stop();
+            }
+            catch (err) {
+                log.error(`Error stopping ${key}:`, err);
+            }
+        });
+        await Promise.all(stops);
+        this.ingestors.clear();
+    }
+    /**
+     * Get events for a specific caller and connection.
+     * @param callerAlias  The caller whose events to retrieve.
+     * @param connectionAlias  The connection to filter by.
+     * @param afterId  Return events with id > afterId. Pass -1 for all.
+     */
+    getEvents(callerAlias, connectionAlias, afterId = -1) {
+        const key = `${callerAlias}:${connectionAlias}`;
+        const ingestor = this.ingestors.get(key);
+        if (!ingestor)
+            return [];
+        return ingestor.getEvents(afterId);
+    }
+    /**
+     * Get events across all ingestors for a caller, sorted chronologically.
+     * @param callerAlias  The caller whose events to retrieve.
+     * @param afterId  Return events with id > afterId. Pass -1 for all.
+     */
+    getAllEvents(callerAlias, afterId = -1) {
+        const events = [];
+        const prefix = `${callerAlias}:`;
+        for (const [key, ingestor] of this.ingestors) {
+            if (key.startsWith(prefix)) {
+                events.push(...ingestor.getEvents(afterId));
+            }
+        }
+        // Sort by receivedAt (ISO strings sort lexicographically)
+        events.sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
+        return events;
+    }
+    /**
+     * Get status of all ingestors for a caller.
+     */
+    getStatuses(callerAlias) {
+        const statuses = [];
+        const prefix = `${callerAlias}:`;
+        for (const [key, ingestor] of this.ingestors) {
+            if (key.startsWith(prefix)) {
+                statuses.push(ingestor.getStatus());
+            }
+        }
+        return statuses;
+    }
+    /**
+     * Find all webhook ingestor instances that match a given webhook path.
+     * Returns all matching instances across all callers (for fan-out dispatch).
+     *
+     * @param path - The webhook path segment (e.g., 'github' from /webhooks/github).
+     */
+    getWebhookIngestors(path) {
+        const matches = [];
+        for (const ingestor of this.ingestors.values()) {
+            if (ingestor instanceof WebhookIngestor && ingestor.webhookPath === path) {
+                matches.push(ingestor);
+            }
+        }
+        return matches;
+    }
+    /**
+     * Merge caller-level ingestor overrides into a copy of the template config.
+     * Override fields replace template values; omitted fields inherit the template defaults.
+     */
+    static mergeIngestorConfig(templateConfig, overrides) {
+        if (!overrides)
+            return templateConfig;
+        // Deep-copy to avoid mutating the shared template
+        const merged = {
+            type: templateConfig.type,
+            ...(templateConfig.websocket && {
+                websocket: { ...templateConfig.websocket },
+            }),
+            ...(templateConfig.webhook && {
+                webhook: { ...templateConfig.webhook },
+            }),
+            ...(templateConfig.poll && {
+                poll: { ...templateConfig.poll },
+            }),
+        };
+        // Apply WebSocket-specific overrides
+        if (merged.websocket) {
+            const ws = merged.websocket;
+            if (overrides.intents !== undefined)
+                ws.intents = overrides.intents;
+            if (overrides.eventFilter !== undefined)
+                ws.eventFilter = overrides.eventFilter;
+            if (overrides.guildIds !== undefined)
+                ws.guildIds = overrides.guildIds;
+            if (overrides.channelIds !== undefined)
+                ws.channelIds = overrides.channelIds;
+            if (overrides.userIds !== undefined)
+                ws.userIds = overrides.userIds;
+        }
+        // Apply poll-specific overrides
+        if (merged.poll) {
+            if (overrides.intervalMs !== undefined)
+                merged.poll.intervalMs = overrides.intervalMs;
+        }
+        return merged;
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/remote/ingestors/poll/index.d.ts

@@ -0,0 +1,2 @@
+export { PollIngestor } from './poll-ingestor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/remote/ingestors/poll/index.js

@@ -0,0 +1,2 @@
+export { PollIngestor } from './poll-ingestor.js';
+//# sourceMappingURL=index.js.map

package/dist/remote/ingestors/poll/poll-ingestor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Polling ingestor — interval-based HTTP poller.
+ *
+ * Periodically hits an HTTP endpoint using the connection's resolved
+ * secrets and headers, extracts individual items from the response,
+ * deduplicates by a configurable field, and pushes new items into
+ * the ring buffer.
+ *
+ * Unlike WebSocket ingestors (which maintain persistent connections)
+ * or webhook ingestors (which are passive receivers), poll ingestors
+ * are active requesters on a timer.
+ *
+ * Designed as a single concrete class — all service-specific behavior
+ * (response shape, event type, deduplication field) is parameterized
+ * via `PollIngestorConfig` rather than requiring subclasses.
+ *
+ * @see https://developers.notion.com/reference (Notion — first implementor)
+ * @see https://developers.linear.app/docs/graphql/working-with-the-graphql-api (Linear — first implementor)
+ */
+import { BaseIngestor } from '../base-ingestor.js';
+import type { PollIngestorConfig } from '../types.js';
+export declare class PollIngestor extends BaseIngestor {
+    private pollTimer;
+    private readonly seenIds;
+    private consecutiveErrors;
+    private readonly url;
+    private readonly intervalMs;
+    private readonly method;
+    private readonly body;
+    private readonly deduplicateBy;
+    private readonly responsePath;
+    private readonly eventType;
+    private readonly pollHeaders;
+    /** Resolved headers from the parent connection route (injected by manager). */
+    private readonly routeHeaders;
+    constructor(connectionAlias: string, secrets: Record<string, string>, pollConfig: PollIngestorConfig, 
+    /** Pre-resolved headers from the connection's route. */
+    routeHeaders: Record<string, string>, bufferSize?: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private poll;
+    /**
+     * Extract items from the response using the configured responsePath.
+     * E.g., "results" extracts response.results,
+     * "data.issues.nodes" extracts response.data.issues.nodes.
+     * If no responsePath, returns the response itself (expects a top-level array).
+     */
+    private extractItems;
+    /**
+     * Resolve a dot-separated path on an object.
+     * E.g., "data.name" on { data: { name: "t3_abc" } } → "t3_abc".
+     * Single-segment paths (e.g., "id") resolve as a simple property lookup.
+     */
+    private static resolveNestedPath;
+    /**
+     * Check if an item should be pushed into the buffer (dedup check).
+     * Returns true if the item is new (not previously seen).
+     * Supports dot-separated paths in `deduplicateBy` (e.g., "data.name").
+     */
+    private shouldPush;
+    /**
+     * Prune the seen IDs set to prevent unbounded memory growth.
+     * Removes the oldest half of entries. Since Set preserves insertion order,
+     * we can iterate and delete the first N entries.
+     */
+    private pruneSeenIds;
+    /**
+     * Extract an idempotency key from a poll item using the `deduplicateBy` field.
+     * Supports dot-separated paths (e.g., "data.name").
+     * Returns `undefined` if no dedup field is configured or the field is absent.
+     */
+    private extractItemIdempotencyKey;
+    /**
+     * Resolve ${VAR} placeholders in a string using a secrets map.
+     */
+    static resolvePlaceholders(str: string, secrets: Record<string, string>): string;
+}
+//# sourceMappingURL=poll-ingestor.d.ts.map

package/dist/remote/ingestors/poll/poll-ingestor.js

@@ -0,0 +1,283 @@
+/**
+ * Polling ingestor — interval-based HTTP poller.
+ *
+ * Periodically hits an HTTP endpoint using the connection's resolved
+ * secrets and headers, extracts individual items from the response,
+ * deduplicates by a configurable field, and pushes new items into
+ * the ring buffer.
+ *
+ * Unlike WebSocket ingestors (which maintain persistent connections)
+ * or webhook ingestors (which are passive receivers), poll ingestors
+ * are active requesters on a timer.
+ *
+ * Designed as a single concrete class — all service-specific behavior
+ * (response shape, event type, deduplication field) is parameterized
+ * via `PollIngestorConfig` rather than requiring subclasses.
+ *
+ * @see https://developers.notion.com/reference (Notion — first implementor)
+ * @see https://developers.linear.app/docs/graphql/working-with-the-graphql-api (Linear — first implementor)
+ */
+import { BaseIngestor } from '../base-ingestor.js';
+import { registerIngestorFactory } from '../registry.js';
+import { createLogger } from '../../../shared/logger.js';
+const log = createLogger('poll');
+// ── Constants ─────────────────────────────────────────────────────────
+/** Maximum number of seen IDs to track for deduplication.
+ *  When exceeded, oldest entries are pruned. */
+const MAX_SEEN_IDS = 10_000;
+/** Minimum allowed poll interval (to prevent accidental API flooding). */
+const MIN_INTERVAL_MS = 5_000; // 5 seconds
+/** Maximum consecutive errors before transitioning to 'error' state. */
+const MAX_CONSECUTIVE_ERRORS = 10;
+// ── Poll Ingestor ─────────────────────────────────────────────────────
+export class PollIngestor extends BaseIngestor {
+    pollTimer = null;
+    seenIds = new Set();
+    consecutiveErrors = 0;
+    url;
+    intervalMs;
+    method;
+    body;
+    deduplicateBy;
+    responsePath;
+    eventType;
+    pollHeaders;
+    /** Resolved headers from the parent connection route (injected by manager). */
+    routeHeaders;
+    constructor(connectionAlias, secrets, pollConfig, 
+    /** Pre-resolved headers from the connection's route. */
+    routeHeaders, bufferSize) {
+        super(connectionAlias, 'poll', secrets, bufferSize);
+        // Resolve ${VAR} placeholders in URL
+        this.url = PollIngestor.resolvePlaceholders(pollConfig.url, secrets);
+        this.intervalMs = Math.max(pollConfig.intervalMs, MIN_INTERVAL_MS);
+        this.method = (pollConfig.method ?? 'GET').toUpperCase();
+        this.body = pollConfig.body;
+        this.deduplicateBy = pollConfig.deduplicateBy;
+        this.responsePath = pollConfig.responsePath;
+        this.eventType = pollConfig.eventType ?? 'poll';
+        this.routeHeaders = routeHeaders;
+        // Resolve ${VAR} placeholders in poll-specific headers
+        this.pollHeaders = {};
+        if (pollConfig.headers) {
+            for (const [k, v] of Object.entries(pollConfig.headers)) {
+                this.pollHeaders[k] = PollIngestor.resolvePlaceholders(v, secrets);
+            }
+        }
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    async start() {
+        this.state = 'starting';
+        log.info(`Starting poll ingestor for ${this.connectionAlias} ` +
+            `(${this.method} ${this.url}, every ${this.intervalMs}ms)`);
+        // Do an initial poll immediately
+        await this.poll();
+        // Then set up the recurring interval
+        this.pollTimer = setInterval(() => {
+            void this.poll();
+        }, this.intervalMs);
+        // If the initial poll succeeded, state is already 'connected'.
+        // If it failed, state is 'reconnecting' — the timer will retry.
+    }
+    stop() {
+        this.state = 'stopped';
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        return Promise.resolve();
+    }
+    // ── Core poll logic ──────────────────────────────────────────────
+    async poll() {
+        try {
+            // Build headers: route headers (from connection template) merged with poll-specific headers
+            const headers = {
+                ...this.routeHeaders,
+                ...this.pollHeaders,
+            };
+            // Build request options
+            const fetchOptions = {
+                method: this.method,
+                headers,
+            };
+            // Add body for POST/PUT/PATCH
+            if (this.body !== undefined && this.method !== 'GET' && this.method !== 'HEAD') {
+                if (typeof this.body === 'string') {
+                    fetchOptions.body = PollIngestor.resolvePlaceholders(this.body, this.secrets);
+                }
+                else {
+                    const serialized = JSON.stringify(this.body);
+                    fetchOptions.body = PollIngestor.resolvePlaceholders(serialized, this.secrets);
+                    // Ensure Content-Type is set for JSON bodies
+                    if (!headers['Content-Type'] && !headers['content-type']) {
+                        headers['Content-Type'] = 'application/json';
+                    }
+                }
+            }
+            const response = await fetch(this.url, fetchOptions);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status} ${response.statusText}`);
+            }
+            const responseBody = await response.json();
+            // Extract items array from response using responsePath
+            const items = this.extractItems(responseBody);
+            if (!Array.isArray(items)) {
+                throw new Error(`Expected array at responsePath "${this.responsePath ?? '(root)'}", got ${typeof items}`);
+            }
+            // Process each item
+            let newItemCount = 0;
+            for (const item of items) {
+                if (this.shouldPush(item)) {
+                    const idempotencyKey = this.extractItemIdempotencyKey(item);
+                    this.pushEvent(this.eventType, item, idempotencyKey);
+                    newItemCount++;
+                }
+            }
+            // Success — reset error state
+            this.consecutiveErrors = 0;
+            if (this.state !== 'connected') {
+                this.state = 'connected';
+            }
+            if (newItemCount > 0) {
+                log.info(`${this.connectionAlias}: ${newItemCount} new item(s) from ${items.length} total`);
+            }
+            log.debug(`${this.connectionAlias}: poll complete — ${items.length} items, ${newItemCount} new`);
+        }
+        catch (err) {
+            this.consecutiveErrors++;
+            const message = err instanceof Error ? err.message : String(err);
+            this.errorMessage = message;
+            if (this.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                this.state = 'error';
+                log.error(`${this.connectionAlias}: ${MAX_CONSECUTIVE_ERRORS} consecutive errors, giving up: ${message}`);
+                // Stop the timer on permanent error
+                if (this.pollTimer) {
+                    clearInterval(this.pollTimer);
+                    this.pollTimer = null;
+                }
+            }
+            else {
+                this.state = 'reconnecting';
+                log.warn(`${this.connectionAlias}: poll failed (attempt ${this.consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${message}`);
+            }
+        }
+    }
+    // ── Response parsing ──────────────────────────────────────────────
+    /**
+     * Extract items from the response using the configured responsePath.
+     * E.g., "results" extracts response.results,
+     * "data.issues.nodes" extracts response.data.issues.nodes.
+     * If no responsePath, returns the response itself (expects a top-level array).
+     */
+    extractItems(responseBody) {
+        if (!this.responsePath)
+            return responseBody;
+        const parts = this.responsePath.split('.');
+        let current = responseBody;
+        for (const part of parts) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    // ── Deduplication ──────────────────────────────────────────────────
+    /**
+     * Resolve a dot-separated path on an object.
+     * E.g., "data.name" on { data: { name: "t3_abc" } } → "t3_abc".
+     * Single-segment paths (e.g., "id") resolve as a simple property lookup.
+     */
+    static resolveNestedPath(obj, dotPath) {
+        if (obj === null || obj === undefined || typeof obj !== 'object')
+            return undefined;
+        const parts = dotPath.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Check if an item should be pushed into the buffer (dedup check).
+     * Returns true if the item is new (not previously seen).
+     * Supports dot-separated paths in `deduplicateBy` (e.g., "data.name").
+     */
+    shouldPush(item) {
+        if (!this.deduplicateBy)
+            return true;
+        const idValue = PollIngestor.resolveNestedPath(item, this.deduplicateBy);
+        if (idValue === undefined || idValue === null)
+            return true;
+        // Ensure safe stringification: only accept primitives for dedup IDs
+        const id = typeof idValue === 'string' || typeof idValue === 'number' || typeof idValue === 'boolean'
+            ? String(idValue)
+            : JSON.stringify(idValue);
+        if (this.seenIds.has(id))
+            return false;
+        // Add to seen set, prune if over limit
+        this.seenIds.add(id);
+        if (this.seenIds.size > MAX_SEEN_IDS) {
+            this.pruneSeenIds();
+        }
+        return true;
+    }
+    /**
+     * Prune the seen IDs set to prevent unbounded memory growth.
+     * Removes the oldest half of entries. Since Set preserves insertion order,
+     * we can iterate and delete the first N entries.
+     */
+    pruneSeenIds() {
+        const pruneCount = Math.floor(this.seenIds.size / 2);
+        let removed = 0;
+        for (const id of this.seenIds) {
+            if (removed >= pruneCount)
+                break;
+            this.seenIds.delete(id);
+            removed++;
+        }
+        log.debug(`${this.connectionAlias}: pruned ${removed} seen IDs (${this.seenIds.size} remaining)`);
+    }
+    // ── Idempotency ─────────────────────────────────────────────────
+    /**
+     * Extract an idempotency key from a poll item using the `deduplicateBy` field.
+     * Supports dot-separated paths (e.g., "data.name").
+     * Returns `undefined` if no dedup field is configured or the field is absent.
+     */
+    extractItemIdempotencyKey(item) {
+        if (!this.deduplicateBy)
+            return undefined;
+        const idValue = PollIngestor.resolveNestedPath(item, this.deduplicateBy);
+        if (idValue === undefined || idValue === null)
+            return undefined;
+        const id = typeof idValue === 'string' || typeof idValue === 'number' || typeof idValue === 'boolean'
+            ? String(idValue)
+            : JSON.stringify(idValue);
+        return `poll:${this.connectionAlias}:${id}`;
+    }
+    // ── Helpers ────────────────────────────────────────────────────────
+    /**
+     * Resolve ${VAR} placeholders in a string using a secrets map.
+     */
+    static resolvePlaceholders(str, secrets) {
+        return str.replace(/\$\{(\w+)\}/g, (match, name) => {
+            if (name in secrets)
+                return secrets[name];
+            return match;
+        });
+    }
+}
+// ── Self-registration ──────────────────────────────────────────────────
+registerIngestorFactory('poll', (connectionAlias, config, secrets, bufferSize) => {
+    if (!config.poll) {
+        log.error(`Missing poll config for ${connectionAlias}`);
+        return null;
+    }
+    return new PollIngestor(connectionAlias, secrets, config.poll, 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-condition -- route headers injected by manager via private property; may be absent
+    config._resolvedRouteHeaders ?? {}, bufferSize);
+});
+//# sourceMappingURL=poll-ingestor.js.map

package/dist/remote/ingestors/registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Ingestor factory registry.
+ *
+ * Decouples the IngestorManager from specific ingestor implementations.
+ * Each provider (Discord, Slack, webhook, poll) registers its own factory
+ * function at module load time; the manager calls `createIngestor()` without
+ * knowing which concrete classes exist.
+ */
+import type { BaseIngestor } from './base-ingestor.js';
+import type { IngestorConfig } from './types.js';
+/** Signature for a factory that creates an ingestor from its config. */
+export type IngestorFactory = (connectionAlias: string, config: IngestorConfig, secrets: Record<string, string>, bufferSize?: number) => BaseIngestor | null;
+/**
+ * Register a factory for a given ingestor key.
+ *
+ * Convention for keys:
+ * - WebSocket protocols: `websocket:<protocol>` (e.g., `websocket:discord`, `websocket:slack`)
+ * - Webhook protocols: `webhook:<protocol>` (e.g., `webhook:generic` for GitHub, `webhook:stripe`)
+ * - Other types: the type name directly (e.g., `poll`)
+ */
+export declare function registerIngestorFactory(key: string, factory: IngestorFactory): void;
+/**
+ * Create an ingestor instance using the registered factory for its config type.
+ *
+ * For WebSocket ingestors, the key is `websocket:<protocol>`.
+ * For Webhook ingestors, the key is `webhook:<protocol>` (default: `webhook:generic`).
+ * For other types, the key is just the type name.
+ *
+ * Returns `null` if no factory is registered or if the factory declines to create.
+ */
+export declare function createIngestor(connectionAlias: string, config: IngestorConfig, secrets: Record<string, string>, bufferSize?: number): BaseIngestor | null;
+//# sourceMappingURL=registry.d.ts.map

package/dist/remote/ingestors/registry.js

@@ -0,0 +1,46 @@
+/**
+ * Ingestor factory registry.
+ *
+ * Decouples the IngestorManager from specific ingestor implementations.
+ * Each provider (Discord, Slack, webhook, poll) registers its own factory
+ * function at module load time; the manager calls `createIngestor()` without
+ * knowing which concrete classes exist.
+ */
+import { createLogger } from '../../shared/logger.js';
+const log = createLogger('ingestor');
+/** Registered factories keyed by type string (e.g., 'websocket:discord'). */
+const factories = new Map();
+/**
+ * Register a factory for a given ingestor key.
+ *
+ * Convention for keys:
+ * - WebSocket protocols: `websocket:<protocol>` (e.g., `websocket:discord`, `websocket:slack`)
+ * - Webhook protocols: `webhook:<protocol>` (e.g., `webhook:generic` for GitHub, `webhook:stripe`)
+ * - Other types: the type name directly (e.g., `poll`)
+ */
+export function registerIngestorFactory(key, factory) {
+    factories.set(key, factory);
+}
+/**
+ * Create an ingestor instance using the registered factory for its config type.
+ *
+ * For WebSocket ingestors, the key is `websocket:<protocol>`.
+ * For Webhook ingestors, the key is `webhook:<protocol>` (default: `webhook:generic`).
+ * For other types, the key is just the type name.
+ *
+ * Returns `null` if no factory is registered or if the factory declines to create.
+ */
+export function createIngestor(connectionAlias, config, secrets, bufferSize) {
+    const key = config.type === 'websocket'
+        ? `websocket:${config.websocket?.protocol ?? 'generic'}`
+        : config.type === 'webhook'
+            ? `webhook:${config.webhook?.protocol ?? 'generic'}`
+            : config.type;
+    const factory = factories.get(key);
+    if (!factory) {
+        log.error(`No factory registered for "${key}" (${connectionAlias})`);
+        return null;
+    }
+    return factory(connectionAlias, config, secrets, bufferSize);
+}
+//# sourceMappingURL=registry.js.map