@wolpertingerlabs/drawlatch 1.0.0-alpha.2 → 1.0.0-alpha.29

package/dist/remote/ingestors/discord/discord-gateway.d.ts

@@ -37,9 +37,9 @@ export declare class DiscordGatewayIngestor extends BaseIngestor {
     private readonly guildIds;
     private readonly channelIds;
     private readonly userIds;
-    constructor(connectionAlias: string, secrets: Record<string, string>, wsConfig: WebSocketIngestorConfig, bufferSize?: number);
+    constructor(connectionAlias: string, secrets: Record<string, string>, wsConfig: WebSocketIngestorConfig, bufferSize?: number, instanceId?: string);
     start(): Promise<void>;
-    stop(): Promise<void>;
+    stop(_permanent?: boolean): Promise<void>;
     private connect;
     private handlePayload;
     private handleHello;

package/dist/remote/ingestors/discord/discord-gateway.js

@@ -41,8 +41,8 @@ export class DiscordGatewayIngestor extends BaseIngestor {
     guildIds;
     channelIds;
     userIds;
-    constructor(connectionAlias, secrets, wsConfig, bufferSize) {
-        super(connectionAlias, 'websocket', secrets, bufferSize);
+    constructor(connectionAlias, secrets, wsConfig, bufferSize, instanceId) {
+        super(connectionAlias, 'websocket', secrets, bufferSize, instanceId);
         this.wsConfig = wsConfig;
         this.gatewayUrl = wsConfig.gatewayUrl;
         this.intents = wsConfig.intents ?? DEFAULT_INTENTS;
@@ -56,12 +56,35 @@ export class DiscordGatewayIngestor extends BaseIngestor {
         this.connect(this.gatewayUrl);
         return Promise.resolve();
     }
-    stop() {
+    stop(_permanent) {
         this.state = 'stopped';
         this.clearAllTimers();
         if (this.ws) {
-            this.ws.close(1000, 'Shutting down');
+            const ws = this.ws;
             this.ws = null;
+            // Wait for the WebSocket to fully close before resolving.
+            // This prevents a race where the old connection is still alive when a new
+            // ingestor starts. For Discord, this avoids the old gateway session
+            // lingering while a new IDENTIFY is sent (which Discord may reject
+            // if it sees two sessions for the same bot token).
+            return new Promise((resolve) => {
+                const onClose = () => {
+                    ws.removeEventListener('close', onClose);
+                    resolve();
+                };
+                if (ws.readyState === WebSocket.CLOSED) {
+                    resolve();
+                }
+                else {
+                    ws.addEventListener('close', onClose);
+                    ws.close(1000, 'Shutting down');
+                    // Safety timeout — don't block forever if close event never fires
+                    setTimeout(() => {
+                        ws.removeEventListener('close', onClose);
+                        resolve();
+                    }, 5000);
+                }
+            });
         }
         return Promise.resolve();
     }
@@ -331,11 +354,11 @@ export class DiscordGatewayIngestor extends BaseIngestor {
     }
 }
 // ── Self-registration ────────────────────────────────────────────────────
-registerIngestorFactory('websocket:discord', (connectionAlias, config, secrets, bufferSize) => {
+registerIngestorFactory('websocket:discord', (connectionAlias, config, secrets, bufferSize, instanceId) => {
     if (!config.websocket) {
         log.error(`Missing websocket config for ${connectionAlias}`);
         return null;
     }
-    return new DiscordGatewayIngestor(connectionAlias, secrets, config.websocket, bufferSize);
+    return new DiscordGatewayIngestor(connectionAlias, secrets, config.websocket, bufferSize, instanceId);
 });
 //# sourceMappingURL=discord-gateway.js.map

package/dist/remote/ingestors/e2e/setup.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Shared E2E test setup for connection ingestor tests.
+ *
+ * Provides helpers to:
+ *   - Load .env.e2e environment variables
+ *   - Build a RemoteServerConfig with in-memory keys and requested connections
+ *   - Boot an Express server on a random port
+ *   - Generate valid webhook signatures (GitHub, Trello)
+ *   - Wait for ingestor state transitions and event arrival
+ */
+import type { Server } from 'node:http';
+import { IngestorManager } from '../manager.js';
+import type { RemoteServerConfig } from '../../../shared/config.js';
+import type { IngestedEvent, IngestorState } from '../types.js';
+export declare function loadE2EEnv(): void;
+/**
+ * Check that all required env vars are set.
+ * Returns the missing var names (empty array = all present).
+ */
+export declare function checkEnvVars(vars: string[]): string[];
+/**
+ * Build a RemoteServerConfig for E2E tests.
+ *
+ * Creates a single caller ("e2e-client") with the requested connections.
+ * Env vars are injected into caller.env so secret resolution works against
+ * process.env (already loaded by loadE2EEnv).
+ */
+export declare function buildE2EConfig(connections: string[], opts?: {
+    env?: Record<string, string>;
+    ingestorOverrides?: Record<string, Record<string, unknown>>;
+}): RemoteServerConfig;
+export interface E2EServer {
+    server: Server;
+    baseUrl: string;
+    ingestorManager: IngestorManager;
+    /** Gracefully shut down server and stop all ingestors. */
+    teardown: () => Promise<void>;
+}
+/**
+ * Boot an Express server with the given config on a random port.
+ * Starts all ingestors and returns handles for testing.
+ */
+export declare function bootServer(config: RemoteServerConfig): Promise<E2EServer>;
+/** Generate a valid GitHub HMAC-SHA256 signature for a raw body. */
+export declare function signGitHubPayload(rawBody: string | Buffer, secret: string): string;
+/** Generate a valid Trello HMAC-SHA1 base64 signature for body + callbackUrl. */
+export declare function signTrelloPayload(rawBody: string | Buffer, callbackUrl: string, secret: string): string;
+/**
+ * Wait for an ingestor to reach a specific state.
+ * Polls every 250ms until the timeout is reached.
+ */
+export declare function waitForIngestorState(manager: IngestorManager, callerAlias: string, connection: string, targetState: IngestorState, timeoutMs?: number): Promise<void>;
+/**
+ * Poll until at least one event appears for a connection.
+ * Returns the events array once non-empty.
+ */
+export declare function pollUntilEvent(manager: IngestorManager, callerAlias: string, connection: string, timeoutMs?: number): Promise<IngestedEvent[]>;
+/** Common shape every IngestedEvent must satisfy (for use with toMatchObject). */
+export declare const INGESTED_EVENT_SHAPE: {
+    id: any;
+    idempotencyKey: any;
+    receivedAt: any;
+    receivedAtMs: any;
+    callerAlias: string;
+    source: any;
+    eventType: any;
+    data: any;
+};
+//# sourceMappingURL=setup.d.ts.map

package/dist/remote/ingestors/e2e/setup.js

@@ -0,0 +1,147 @@
+/**
+ * Shared E2E test setup for connection ingestor tests.
+ *
+ * Provides helpers to:
+ *   - Load .env.e2e environment variables
+ *   - Build a RemoteServerConfig with in-memory keys and requested connections
+ *   - Boot an Express server on a random port
+ *   - Generate valid webhook signatures (GitHub, Trello)
+ *   - Wait for ingestor state transitions and event arrival
+ */
+import crypto from 'node:crypto';
+import path from 'node:path';
+import dotenv from 'dotenv';
+import { expect } from 'vitest';
+import { createApp } from '../../server.js';
+import { generateKeyBundle, extractPublicKeys } from '../../../shared/crypto/index.js';
+import { IngestorManager } from '../manager.js';
+// ── Env loading ─────────────────────────────────────────────────────────
+/** Load .env.e2e from the project root (idempotent). */
+let envLoaded = false;
+export function loadE2EEnv() {
+    if (envLoaded)
+        return;
+    dotenv.config({ path: path.resolve(import.meta.dirname, '../../../../.env.e2e') });
+    envLoaded = true;
+}
+/**
+ * Check that all required env vars are set.
+ * Returns the missing var names (empty array = all present).
+ */
+export function checkEnvVars(vars) {
+    loadE2EEnv();
+    return vars.filter((v) => !process.env[v]);
+}
+// ── Config builder ──────────────────────────────────────────────────────
+/**
+ * Build a RemoteServerConfig for E2E tests.
+ *
+ * Creates a single caller ("e2e-client") with the requested connections.
+ * Env vars are injected into caller.env so secret resolution works against
+ * process.env (already loaded by loadE2EEnv).
+ */
+export function buildE2EConfig(connections, opts) {
+    return {
+        host: '127.0.0.1',
+        port: 0,
+        callers: {
+            'e2e-client': {
+                connections,
+                env: opts?.env,
+                ingestorOverrides: opts?.ingestorOverrides,
+            },
+        },
+        rateLimitPerMinute: 600,
+    };
+}
+/**
+ * Boot an Express server with the given config on a random port.
+ * Starts all ingestors and returns handles for testing.
+ */
+export async function bootServer(config) {
+    const serverKeys = generateKeyBundle();
+    const clientKeys = generateKeyBundle();
+    const clientPub = extractPublicKeys(clientKeys);
+    const ingestorManager = new IngestorManager(config);
+    const app = createApp({
+        config,
+        ownKeys: serverKeys,
+        authorizedPeers: [{ alias: 'e2e-client', keys: clientPub }],
+        ingestorManager,
+        disableRateLimiting: true,
+    });
+    // Start ingestors
+    await ingestorManager.startAll();
+    // Listen on random port
+    const server = await new Promise((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+    });
+    const addr = server.address();
+    const baseUrl = `http://127.0.0.1:${addr.port}`;
+    return {
+        server,
+        baseUrl,
+        ingestorManager,
+        teardown: async () => {
+            await ingestorManager.stopAll();
+            await new Promise((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            });
+        },
+    };
+}
+// ── Signature helpers ───────────────────────────────────────────────────
+/** Generate a valid GitHub HMAC-SHA256 signature for a raw body. */
+export function signGitHubPayload(rawBody, secret) {
+    const buf = typeof rawBody === 'string' ? Buffer.from(rawBody) : rawBody;
+    const sig = crypto.createHmac('sha256', secret).update(buf).digest('hex');
+    return `sha256=${sig}`;
+}
+/** Generate a valid Trello HMAC-SHA1 base64 signature for body + callbackUrl. */
+export function signTrelloPayload(rawBody, callbackUrl, secret) {
+    const bodyStr = typeof rawBody === 'string' ? rawBody : rawBody.toString('utf-8');
+    return crypto.createHmac('sha1', secret).update(bodyStr + callbackUrl).digest('base64');
+}
+// ── Polling helpers ─────────────────────────────────────────────────────
+/**
+ * Wait for an ingestor to reach a specific state.
+ * Polls every 250ms until the timeout is reached.
+ */
+export async function waitForIngestorState(manager, callerAlias, connection, targetState, timeoutMs = 15_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const statuses = manager.getStatuses(callerAlias);
+        const status = statuses.find((s) => s.connection === connection);
+        if (status?.state === targetState)
+            return;
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    throw new Error(`Timed out waiting for ${connection} to reach state "${targetState}" (${timeoutMs}ms)`);
+}
+/**
+ * Poll until at least one event appears for a connection.
+ * Returns the events array once non-empty.
+ */
+export async function pollUntilEvent(manager, callerAlias, connection, timeoutMs = 10_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const events = manager.getEvents(callerAlias, connection);
+        if (events.length > 0)
+            return events;
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    throw new Error(`Timed out waiting for events from ${connection} (${timeoutMs}ms)`);
+}
+// ── Shared assertions ───────────────────────────────────────────────────
+/** Common shape every IngestedEvent must satisfy (for use with toMatchObject). */
+export const INGESTED_EVENT_SHAPE = {
+    id: expect.any(Number),
+    idempotencyKey: expect.any(String),
+    receivedAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
+    receivedAtMs: expect.any(Number),
+    callerAlias: 'e2e-client',
+    source: expect.any(String),
+    eventType: expect.any(String),
+    data: expect.anything(),
+};
+//# sourceMappingURL=setup.js.map

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

@@ -1,15 +1,19 @@
 /**
  * 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).
+ * Keyed by `callerAlias:connectionAlias:instanceId`, 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.
  *
+ * Supports multi-instance listeners: when a caller defines `listenerInstances`
+ * for a connection, one ingestor is spawned per instanceId (e.g., watching
+ * multiple Trello boards or multiple Reddit subreddits simultaneously).
+ *
  * 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 { type IngestorOverrides, type RemoteServerConfig } from '../../shared/config.js';
+import { type IngestorOverrides, type RemoteServerConfig, type ListenerConfigField } from '../../shared/config.js';
 import type { IngestedEvent, IngestorConfig, IngestorStatus } from './types.js';
 import { WebhookIngestor } from './webhook/base-webhook-ingestor.js';
 import './discord/discord-gateway.js';
@@ -18,27 +22,66 @@ import './webhook/github-webhook-ingestor.js';
 import './webhook/stripe-webhook-ingestor.js';
 import './webhook/trello-webhook-ingestor.js';
 import './poll/poll-ingestor.js';
+/** Sentinel instance ID used for single-instance (default) connections. */
+declare const DEFAULT_INSTANCE_ID = "_default";
+/** Build a composite ingestor map key. */
+declare function makeKey(caller: string, connection: string, instance?: string): string;
+/** Parse a composite ingestor map key. */
+declare function parseKey(key: string): {
+    caller: string;
+    connection: string;
+    instance: string;
+};
+interface LifecycleResult {
+    success: boolean;
+    connection: string;
+    instanceId?: string;
+    state?: string;
+    error?: string;
+}
 export declare class IngestorManager {
     private readonly config;
-    /** Active ingestor instances, keyed by `callerAlias:connectionAlias`. */
+    /** Active ingestor instances, keyed by `callerAlias:connectionAlias:instanceId`. */
     private ingestors;
-    constructor(config: RemoteServerConfig);
+    /** Trigger rule engines per caller. Created during startAll() for callers with triggerRules. */
+    private triggerEngines;
+    /** Global event listeners (e.g. SSE streams). Called for every event from every ingestor. */
+    private eventListeners;
+    /**
+     * Optional config loader for hot-reload support. When provided, `startOne()`
+     * uses it to get fresh config from disk instead of the constructor snapshot.
+     */
+    private configLoader;
+    constructor(config: RemoteServerConfig, configLoader?: () => RemoteServerConfig);
+    /** Return fresh config if a loader is available, otherwise the constructor snapshot. */
+    private getConfig;
     /**
      * Start ingestors for all callers whose connections have an `ingestor` config.
      * Called once when the remote server starts listening.
+     *
+     * For connections with `listenerInstances`, spawns one ingestor per instanceId.
+     * For connections without, spawns a single default instance (backward compatible).
      */
     startAll(): Promise<void>;
+    /**
+     * Internal: create, register, and start a single ingestor instance.
+     */
+    private startIngestor;
+    /**
+     * Initialize trigger rule engines for callers with triggerRules config.
+     * Subscribes to 'event' emissions from matching ingestors and dispatches
+     * to Claude Code remote triggers.
+     */
+    private initTriggerEngines;
     /**
      * Stop all running ingestors. Called during graceful shutdown.
      */
     stopAll(): Promise<void>;
     /**
-     * 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.
+     * Get events for a specific caller and connection, optionally filtered by instance.
+     * When instanceId is omitted, aggregates events from all instances of that connection.
      */
-    getEvents(callerAlias: string, connectionAlias: string, afterId?: number): IngestedEvent[];
+    getEvents(callerAlias: string, connectionAlias: string, afterId?: number, instanceId?: string): IngestedEvent[];
     /**
      * Get events across all ingestors for a caller, sorted chronologically.
      * @param callerAlias  The caller whose events to retrieve.
@@ -49,6 +92,23 @@ export declare class IngestorManager {
      * Get status of all ingestors for a caller.
      */
     getStatuses(callerAlias: string): IngestorStatus[];
+    /**
+     * Get status of every ingestor across all callers, augmented with the
+     * owning caller alias. Used by the read-only /admin API to render a global
+     * dashboard view without iterating per-caller.
+     */
+    getAllStatuses(): (IngestorStatus & {
+        callerAlias: string;
+    })[];
+    /**
+     * Subscribe to all events from all ingestors (current and future).
+     * Used by the SSE /events/stream endpoint to fan out events to CLI watchers.
+     */
+    onEvent(listener: (event: IngestedEvent) => void): void;
+    /** Unsubscribe a global event listener. */
+    offEvent(listener: (event: IngestedEvent) => void): void;
+    /** Forward an ingestor event to all global listeners. */
+    private notifyEventListeners;
     /**
      * Find all webhook ingestor instances that match a given webhook path.
      * Returns all matching instances across all callers (for fan-out dispatch).
@@ -56,10 +116,50 @@ export declare class IngestorManager {
      * @param path - The webhook path segment (e.g., 'github' from /webhooks/github).
      */
     getWebhookIngestors(path: string): WebhookIngestor[];
+    /**
+     * Start a single ingestor for a specific caller+connection pair.
+     * When instanceId is provided, starts that specific instance.
+     * When omitted, starts the default instance (or all instances if listenerInstances is defined).
+     */
+    startOne(callerAlias: string, connectionAlias: string, instanceId?: string): Promise<LifecycleResult | LifecycleResult[]>;
+    /** Internal: start a single specific instance. */
+    private startOneInstance;
+    /**
+     * Stop a single ingestor for a specific caller+connection pair.
+     * When instanceId is provided, stops that specific instance.
+     * When omitted, stops all instances of that connection.
+     */
+    stopOne(callerAlias: string, connectionAlias: string, instanceId?: string, options?: {
+        permanent?: boolean;
+    }): Promise<LifecycleResult | LifecycleResult[]>;
+    /** Internal: stop a single specific instance. */
+    private stopOneInstance;
+    /**
+     * Restart a single ingestor (stop + start). Useful after configuration changes.
+     */
+    restartOne(callerAlias: string, connectionAlias: string, instanceId?: string): Promise<LifecycleResult | LifecycleResult[]>;
+    /**
+     * Check if an ingestor exists (running or otherwise) for a caller+connection pair.
+     * When instanceId is provided, checks that specific instance.
+     * When omitted, checks if any instance exists for that connection.
+     */
+    has(callerAlias: string, connectionAlias: string, instanceId?: string): boolean;
     /**
      * 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: IngestorConfig, overrides?: IngestorOverrides): IngestorConfig;
+    /**
+     * Apply instance-specific params from IngestorOverrides to the effective config and secrets.
+     *
+     * For each param, checks the connection's listenerConfig fields:
+     *   - If the field has `overrideKey`, injects `params[key]` as `secrets[overrideKey]`
+     *     (used by poll ingestors for URL template resolution, e.g., REDDIT_SUBREDDIT).
+     *   - If the field has `instanceKey` and the config is a webhook, attaches
+     *     the value to the webhook config for payload discrimination (e.g., _boardId for Trello).
+     *   - Otherwise, attaches the value as a generic `_instanceParams` bag on the config.
+     */
+    static applyInstanceParams(config: IngestorConfig, secrets: Record<string, string>, params: Record<string, unknown>, fields: ListenerConfigField[]): void;
 }
+export { makeKey, parseKey, DEFAULT_INSTANCE_ID };
 //# sourceMappingURL=manager.d.ts.map