@wolpertingerlabs/drawlatch 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/remote/ingestors/manager.js

@@ -15,6 +15,7 @@
  */
 import { resolveCallerRoutes, resolveRoutes, resolveSecrets, } from '../../shared/config.js';
 import { createLogger } from '../../shared/logger.js';
+import { TriggerRuleEngine } from '../triggers/rule-engine.js';
 const log = createLogger('ingestor');
 import { createIngestor } from './registry.js';
 import { WebhookIngestor } from './webhook/base-webhook-ingestor.js';
@@ -48,8 +49,22 @@ export class IngestorManager {
     config;
     /** Active ingestor instances, keyed by `callerAlias:connectionAlias:instanceId`. */
     ingestors = new Map();
-    constructor(config) {
+    /** Trigger rule engines per caller. Created during startAll() for callers with triggerRules. */
+    triggerEngines = new Map();
+    /** Global event listeners (e.g. SSE streams). Called for every event from every ingestor. */
+    eventListeners = new Set();
+    /**
+     * Optional config loader for hot-reload support. When provided, `startOne()`
+     * uses it to get fresh config from disk instead of the constructor snapshot.
+     */
+    configLoader;
+    constructor(config, configLoader) {
         this.config = config;
+        this.configLoader = configLoader;
+    }
+    /** Return fresh config if a loader is available, otherwise the constructor snapshot. */
+    getConfig() {
+        return this.configLoader ? this.configLoader() : this.config;
     }
     /**
      * Start ingestors for all callers whose connections have an `ingestor` config.
@@ -63,7 +78,7 @@ export class IngestorManager {
             // Resolve routes for this caller (raw + resolved)
             const rawRoutes = resolveCallerRoutes(this.config, callerAlias);
             const callerEnvResolved = resolveSecrets(callerConfig.env ?? {});
-            const resolvedRoutes = resolveRoutes(rawRoutes, callerEnvResolved);
+            const resolvedRoutes = resolveRoutes(rawRoutes, callerEnvResolved, callerAlias);
             for (let i = 0; i < rawRoutes.length; i++) {
                 const rawRoute = rawRoutes[i];
                 const resolvedRoute = resolvedRoutes[i];
@@ -104,6 +119,8 @@ export class IngestorManager {
         if (count > 0) {
             log.info(`${count} ingestor(s) started`);
         }
+        // Wire up trigger rule engines for callers that have triggerRules
+        this.initTriggerEngines();
     }
     /**
      * Internal: create, register, and start a single ingestor instance.
@@ -124,7 +141,14 @@ export class IngestorManager {
         }
         const ingestor = createIngestor(connectionAlias, effectiveConfig, instanceSecrets, overrides?.bufferSize, instanceId);
         if (ingestor) {
+            const { caller } = parseKey(key);
+            ingestor.callerAlias = caller;
             this.ingestors.set(key, ingestor);
+            // Forward events to global listeners (SSE streams, etc.)
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any -- BaseIngestor extends EventEmitter; .on() is inherited
+            ingestor.on('event', (event) => {
+                this.notifyEventListeners(event);
+            });
             log.info(`Starting ${effectiveConfig.type} ingestor for ${key}`);
             try {
                 await ingestor.start();
@@ -134,6 +158,35 @@ export class IngestorManager {
             }
         }
     }
+    /**
+     * Initialize trigger rule engines for callers with triggerRules config.
+     * Subscribes to 'event' emissions from matching ingestors and dispatches
+     * to Claude Code remote triggers.
+     */
+    initTriggerEngines() {
+        const config = this.getConfig();
+        for (const [callerAlias, callerConfig] of Object.entries(config.callers)) {
+            if (!callerConfig.triggerRules || callerConfig.triggerRules.length === 0)
+                continue;
+            // Resolve caller-level secrets for API key access
+            const callerEnvResolved = resolveSecrets(callerConfig.env ?? {});
+            const engine = new TriggerRuleEngine(callerConfig.triggerRules, callerEnvResolved);
+            if (engine.activeRuleCount === 0)
+                continue;
+            this.triggerEngines.set(callerAlias, engine);
+            // Subscribe the engine to all ingestors belonging to this caller
+            for (const [key, ingestor] of this.ingestors) {
+                const { caller } = parseKey(key);
+                if (caller !== callerAlias)
+                    continue;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any -- BaseIngestor extends EventEmitter; .on() is inherited
+                ingestor.on('event', (event) => {
+                    engine.handleEvent(event);
+                });
+            }
+            log.info(`Trigger rule engine for ${callerAlias}: ${engine.activeRuleCount} active rule(s)`);
+        }
+    }
     /**
      * Stop all running ingestors. Called during graceful shutdown.
      */
@@ -204,6 +257,41 @@ export class IngestorManager {
         }
         return statuses;
     }
+    /**
+     * 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() {
+        const out = [];
+        for (const [key, ingestor] of this.ingestors) {
+            const { caller } = parseKey(key);
+            out.push({ ...ingestor.getStatus(), callerAlias: caller });
+        }
+        return out;
+    }
+    /**
+     * 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) {
+        this.eventListeners.add(listener);
+    }
+    /** Unsubscribe a global event listener. */
+    offEvent(listener) {
+        this.eventListeners.delete(listener);
+    }
+    /** Forward an ingestor event to all global listeners. */
+    notifyEventListeners(event) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Don't let a broken listener crash ingestor event processing
+            }
+        }
+    }
     /**
      * Find all webhook ingestor instances that match a given webhook path.
      * Returns all matching instances across all callers (for fan-out dispatch).
@@ -226,25 +314,41 @@ export class IngestorManager {
      * When omitted, starts the default instance (or all instances if listenerInstances is defined).
      */
     async startOne(callerAlias, connectionAlias, instanceId) {
-        const callerConfig = this.config.callers[callerAlias];
+        // Get fresh config (from disk in production, or constructor snapshot in tests)
+        // so we pick up changes made by tool handlers (e.g. set_connection_enabled,
+        // set_listener_params, set_secrets) without requiring a server restart.
+        const config = this.getConfig();
+        const callerConfig = config.callers[callerAlias];
         if (!callerConfig) {
-            return { success: false, connection: connectionAlias, error: `Unknown caller: ${callerAlias}` };
+            return {
+                success: false,
+                connection: connectionAlias,
+                error: `Unknown caller: ${callerAlias}`,
+            };
         }
         const connectionIndex = callerConfig.connections.indexOf(connectionAlias);
         if (connectionIndex === -1) {
-            return { success: false, connection: connectionAlias, error: `Caller does not have connection: ${connectionAlias}` };
+            return {
+                success: false,
+                connection: connectionAlias,
+                error: `Caller does not have connection: ${connectionAlias}`,
+            };
         }
-        const rawRoutes = resolveCallerRoutes(this.config, callerAlias);
+        const rawRoutes = resolveCallerRoutes(config, callerAlias);
         const callerEnvResolved = resolveSecrets(callerConfig.env ?? {});
-        const resolvedRoutes = resolveRoutes(rawRoutes, callerEnvResolved);
+        const resolvedRoutes = resolveRoutes(rawRoutes, callerEnvResolved, callerAlias);
         const rawRoute = rawRoutes[connectionIndex];
         const resolvedRoute = resolvedRoutes[connectionIndex];
         if (!rawRoute.ingestor) {
-            return { success: false, connection: connectionAlias, error: 'This connection does not have an ingestor.' };
+            return {
+                success: false,
+                connection: connectionAlias,
+                error: 'This connection does not have an ingestor.',
+            };
         }
         // If a specific instanceId is given, start just that one
         if (instanceId) {
-            return this.startOneInstance(callerAlias, connectionAlias, instanceId, rawRoute, resolvedRoute);
+            return this.startOneInstance(callerAlias, connectionAlias, instanceId, rawRoute, resolvedRoute, config);
         }
         // If listenerInstances is defined, start all instances
         const instances = callerConfig.listenerInstances?.[connectionAlias];
@@ -253,30 +357,32 @@ export class IngestorManager {
             for (const [instId, instOverrides] of Object.entries(instances)) {
                 if (instOverrides.disabled)
                     continue;
-                results.push(await this.startOneInstance(callerAlias, connectionAlias, instId, rawRoute, resolvedRoute));
+                results.push(await this.startOneInstance(callerAlias, connectionAlias, instId, rawRoute, resolvedRoute, config));
             }
             return results;
         }
         // Single default instance
-        return this.startOneInstance(callerAlias, connectionAlias, undefined, rawRoute, resolvedRoute);
+        return this.startOneInstance(callerAlias, connectionAlias, undefined, rawRoute, resolvedRoute, config);
     }
     /** Internal: start a single specific instance. */
-    async startOneInstance(callerAlias, connectionAlias, instanceId, rawRoute, resolvedRoute) {
+    async startOneInstance(callerAlias, connectionAlias, instanceId, rawRoute, resolvedRoute, config) {
         const key = makeKey(callerAlias, connectionAlias, instanceId ?? DEFAULT_INSTANCE_ID);
         // If already running, return current status
         const existing = this.ingestors.get(key);
         if (existing) {
             const status = existing.getStatus();
-            if (status.state === 'connected' || status.state === 'starting' || status.state === 'reconnecting') {
+            if (status.state === 'connected' ||
+                status.state === 'starting' ||
+                status.state === 'reconnecting') {
                 return { success: true, connection: connectionAlias, instanceId, state: status.state };
             }
             // Remove stopped instance to recreate
             this.ingestors.delete(key);
         }
-        const callerConfig = this.config.callers[callerAlias];
+        const callerCfg = config.callers[callerAlias];
         const overrides = instanceId
-            ? callerConfig.listenerInstances?.[connectionAlias]?.[instanceId]
-            : callerConfig.ingestorOverrides?.[connectionAlias];
+            ? callerCfg.listenerInstances?.[connectionAlias]?.[instanceId]
+            : callerCfg.ingestorOverrides?.[connectionAlias];
         const effectiveConfig = IngestorManager.mergeIngestorConfig(rawRoute.ingestor, overrides);
         // Apply instance params
         const instanceSecrets = { ...resolvedRoute.secrets };
@@ -289,13 +395,29 @@ export class IngestorManager {
         }
         const ingestor = createIngestor(connectionAlias, effectiveConfig, instanceSecrets, overrides?.bufferSize, instanceId);
         if (!ingestor) {
-            return { success: false, connection: connectionAlias, instanceId, error: 'Failed to create ingestor.' };
+            return {
+                success: false,
+                connection: connectionAlias,
+                instanceId,
+                error: 'Failed to create ingestor.',
+            };
         }
+        ingestor.callerAlias = callerAlias;
         this.ingestors.set(key, ingestor);
+        // Forward events to global listeners (SSE streams, etc.)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any -- BaseIngestor extends EventEmitter; .on() is inherited
+        ingestor.on('event', (event) => {
+            this.notifyEventListeners(event);
+        });
         log.info(`Starting ${effectiveConfig.type} ingestor for ${key}`);
         try {
             await ingestor.start();
-            return { success: true, connection: connectionAlias, instanceId, state: ingestor.getStatus().state };
+            return {
+                success: true,
+                connection: connectionAlias,
+                instanceId,
+                state: ingestor.getStatus().state,
+            };
         }
         catch (err) {
             log.error(`Failed to start ${key}:`, err);
@@ -318,9 +440,13 @@ export class IngestorManager {
         }
         // Stop all instances for this connection
         const prefix = `${callerAlias}:${connectionAlias}:`;
-        const keysToStop = Array.from(this.ingestors.keys()).filter(k => k.startsWith(prefix));
+        const keysToStop = Array.from(this.ingestors.keys()).filter((k) => k.startsWith(prefix));
         if (keysToStop.length === 0) {
-            return { success: false, connection: connectionAlias, error: 'No ingestor running for this connection.' };
+            return {
+                success: false,
+                connection: connectionAlias,
+                error: 'No ingestor running for this connection.',
+            };
         }
         if (keysToStop.length === 1) {
             const parsed = parseKey(keysToStop[0]);
@@ -340,7 +466,12 @@ export class IngestorManager {
         const key = makeKey(callerAlias, connectionAlias, instanceId ?? DEFAULT_INSTANCE_ID);
         const ingestor = this.ingestors.get(key);
         if (!ingestor) {
-            return { success: false, connection: connectionAlias, instanceId, error: 'No ingestor running for this connection.' };
+            return {
+                success: false,
+                connection: connectionAlias,
+                instanceId,
+                error: 'No ingestor running for this connection.',
+            };
         }
         log.info(`Stopping ${key}`);
         try {
@@ -444,7 +575,7 @@ export class IngestorManager {
      *   - Otherwise, attaches the value as a generic `_instanceParams` bag on the config.
      */
     static applyInstanceParams(config, secrets, params, fields) {
-        const fieldsByKey = new Map(fields.map(f => [f.key, f]));
+        const fieldsByKey = new Map(fields.map((f) => [f.key, f]));
         for (const [paramKey, paramValue] of Object.entries(params)) {
             const field = fieldsByKey.get(paramKey);
             if (!field)
@@ -461,6 +592,13 @@ export class IngestorManager {
                 if (typeof paramValue === 'string') {
                     secrets[paramKey] = paramValue;
                 }
+                else if (Array.isArray(paramValue) &&
+                    paramValue.length > 0 &&
+                    typeof paramValue[0] === 'string') {
+                    // For text[] instanceKey fields, inject the first element into secrets
+                    // for lifecycle URL ${VAR} resolution (e.g., repoFilter → "owner/repo")
+                    secrets[paramKey] = paramValue[0];
+                }
             }
         }
     }

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

@@ -31,6 +31,8 @@ export declare class PollIngestor extends BaseIngestor {
     private readonly responsePath;
     private readonly eventType;
     private readonly pollHeaders;
+    private readonly useEtag;
+    private lastEtag;
     /** Resolved headers from the parent connection route (injected by manager). */
     private readonly routeHeaders;
     constructor(connectionAlias: string, secrets: Record<string, string>, pollConfig: PollIngestorConfig, 

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

@@ -42,6 +42,8 @@ export class PollIngestor extends BaseIngestor {
     responsePath;
     eventType;
     pollHeaders;
+    useEtag;
+    lastEtag = null;
     /** Resolved headers from the parent connection route (injected by manager). */
     routeHeaders;
     constructor(connectionAlias, secrets, pollConfig, 
@@ -56,6 +58,7 @@ export class PollIngestor extends BaseIngestor {
         this.deduplicateBy = pollConfig.deduplicateBy;
         this.responsePath = pollConfig.responsePath;
         this.eventType = pollConfig.eventType ?? 'poll';
+        this.useEtag = pollConfig.etag ?? false;
         this.routeHeaders = routeHeaders;
         // Resolve ${VAR} placeholders in poll-specific headers
         this.pollHeaders = {};
@@ -95,6 +98,10 @@ export class PollIngestor extends BaseIngestor {
                 ...this.routeHeaders,
                 ...this.pollHeaders,
             };
+            // Add ETag conditional request header if enabled and we have a cached ETag
+            if (this.useEtag && this.lastEtag) {
+                headers['If-None-Match'] = this.lastEtag;
+            }
             // Build request options
             const fetchOptions = {
                 method: this.method,
@@ -115,9 +122,23 @@ export class PollIngestor extends BaseIngestor {
                 }
             }
             const response = await fetch(this.url, fetchOptions);
+            // Handle ETag 304 Not Modified — no new data, not an error
+            if (this.useEtag && response.status === 304) {
+                this.consecutiveErrors = 0;
+                if (this.state !== 'connected')
+                    this.state = 'connected';
+                log.debug(`${this.connectionAlias}: 304 Not Modified (ETag cache hit)`);
+                return;
+            }
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status} ${response.statusText}`);
             }
+            // Store ETag for subsequent conditional requests
+            if (this.useEtag) {
+                const etag = response.headers.get('etag');
+                if (etag)
+                    this.lastEtag = etag;
+            }
             const responseBody = await response.json();
             // Extract items array from response using responsePath
             const items = this.extractItems(responseBody);

package/dist/remote/ingestors/slack/socket-mode.js

@@ -47,8 +47,30 @@ export class SlackSocketModeIngestor extends BaseIngestor {
         this.state = 'stopped';
         this.clearReconnectTimer();
         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, causing Slack to distribute events to the dying
+            // connection (where nobody processes them).
+            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();
     }

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

@@ -86,6 +86,12 @@ export interface PollIngestorConfig {
      *  Values may contain ${VAR} placeholders.
      *  These are merged UNDER the connection's route headers (route headers take precedence). */
     headers?: Record<string, string>;
+    /** Enable ETag-based conditional requests.
+     *  When true, the poller stores the ETag from each successful response and sends
+     *  `If-None-Match` on subsequent requests. HTTP 304 responses are treated as a
+     *  successful no-op (no items, no error). Useful for APIs like GitHub Events
+     *  where 304s do not count against rate limits. */
+    etag?: boolean;
 }
 /** A single event received by an ingestor, stored in the ring buffer. */
 export interface IngestedEvent {
@@ -110,6 +116,8 @@ export interface IngestedEvent {
     receivedAt: string;
     /** Unix timestamp (milliseconds) when the event was received by the ingestor. */
     receivedAtMs: number;
+    /** Caller alias that owns this event (e.g., 'default', 'alice'). */
+    callerAlias: string;
     /** Source connection alias (e.g., 'discord-bot', 'github'). */
     source: string;
     /** Instance identifier for multi-instance listeners (e.g., "project-board").

package/dist/remote/ingestors/webhook/github-webhook-ingestor.d.ts

@@ -19,7 +19,23 @@ export declare class GitHubWebhookIngestor extends WebhookIngestor {
      * Set via `_repoFilter` on the webhook config (injected by IngestorManager).
      */
     private readonly repoFilter;
+    /**
+     * Organization filter for org-level webhook registration.
+     * When set, lifecycle URLs target the org API instead of the repo API.
+     * Set via `_orgFilter` on the webhook config (injected by IngestorManager).
+     */
+    private readonly orgFilter;
     constructor(connectionAlias: string, secrets: Record<string, string>, webhookConfig: WebhookIngestorConfig, bufferSize?: number, instanceId?: string);
+    /**
+     * Return the model ID for multi-instance webhook lifecycle management.
+     * For org-level: the org name. For repo-level: the single repo name.
+     */
+    protected getModelId(): string | undefined;
+    /**
+     * Clone webhookConfig with lifecycle URLs rewritten for org-level endpoints.
+     * Replaces `repos/${repoFilter}` with `orgs/${orgFilter}` in all lifecycle URLs.
+     */
+    private static withOrgLifecycle;
     /**
      * Filter webhooks by repository for multi-instance support.
      * When repoFilter is set, only events from those repos are accepted.

package/dist/remote/ingestors/webhook/github-webhook-ingestor.js

@@ -23,11 +23,57 @@ export class GitHubWebhookIngestor extends WebhookIngestor {
      * Set via `_repoFilter` on the webhook config (injected by IngestorManager).
      */
     repoFilter;
+    /**
+     * Organization filter for org-level webhook registration.
+     * When set, lifecycle URLs target the org API instead of the repo API.
+     * Set via `_orgFilter` on the webhook config (injected by IngestorManager).
+     */
+    orgFilter;
     constructor(connectionAlias, secrets, webhookConfig, bufferSize, instanceId) {
-        super(connectionAlias, secrets, webhookConfig, bufferSize, instanceId);
-        // Repo filter for multi-instance discrimination
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any -- injected by IngestorManager for multi-instance support
-        this.repoFilter = webhookConfig._repoFilter ?? [];
+        const orgFilter = webhookConfig._orgFilter;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+        const repoFilterArr = webhookConfig._repoFilter;
+        // When orgFilter is set, swap lifecycle URLs to use org endpoints
+        if (orgFilter && webhookConfig.lifecycle) {
+            webhookConfig = GitHubWebhookIngestor.withOrgLifecycle(webhookConfig);
+        }
+        else if (!repoFilterArr?.length && !orgFilter && webhookConfig.lifecycle) {
+            // Neither filter set — lifecycle registration can't determine the target
+            log.warn(`${connectionAlias}: No repoFilter or orgFilter set — webhook auto-registration disabled. ` +
+                'Set repoFilter (owner/repo) or orgFilter (org name) to enable.');
+            webhookConfig = { ...webhookConfig, lifecycle: undefined };
+        }
+        super(connectionAlias, secrets, webhookConfig, bufferSize, instanceId);
+        this.repoFilter = repoFilterArr ?? [];
+        this.orgFilter = orgFilter;
+    }
+    /**
+     * Return the model ID for multi-instance webhook lifecycle management.
+     * For org-level: the org name. For repo-level: the single repo name.
+     */
+    getModelId() {
+        if (this.orgFilter)
+            return this.orgFilter;
+        return this.repoFilter.length === 1 ? this.repoFilter[0] : undefined;
+    }
+    /**
+     * Clone webhookConfig with lifecycle URLs rewritten for org-level endpoints.
+     * Replaces `repos/${repoFilter}` with `orgs/${orgFilter}` in all lifecycle URLs.
+     */
+    static withOrgLifecycle(config) {
+        if (!config.lifecycle)
+            return config;
+        const lc = config.lifecycle;
+        const swap = (url) => url.replace('repos/${repoFilter}', 'orgs/${orgFilter}');
+        return {
+            ...config,
+            lifecycle: {
+                list: lc.list ? { ...lc.list, url: swap(lc.list.url) } : undefined,
+                register: lc.register ? { ...lc.register, url: swap(lc.register.url) } : undefined,
+                unregister: lc.unregister ? { ...lc.unregister, url: swap(lc.unregister.url) } : undefined,
+            },
+        };
     }
     /**
      * Filter webhooks by repository for multi-instance support.

package/dist/remote/ingestors/webhook/webhook-lifecycle-manager.js

@@ -25,7 +25,7 @@ function resolveDeep(value, secrets) {
         return resolvePlaceholders(value, secrets);
     }
     if (Array.isArray(value)) {
-        return value.map(item => resolveDeep(item, secrets));
+        return value.map((item) => resolveDeep(item, secrets));
     }
     if (value !== null && typeof value === 'object') {
         const result = {};
@@ -87,34 +87,34 @@ export class WebhookLifecycleManager {
             if (existingWebhooks !== null && this.config.list) {
                 const listConfig = this.config.list;
                 // Find a webhook matching our callback URL (and model ID if applicable)
-                const matching = existingWebhooks.find(wh => {
-                    const rawUrl = wh[listConfig.callbackUrlField];
+                const matching = existingWebhooks.find((wh) => {
+                    const rawUrl = getByPath(wh, listConfig.callbackUrlField);
                     const whCallbackUrl = typeof rawUrl === 'string' ? rawUrl : '';
                     const urlMatch = whCallbackUrl === callbackUrl;
                     if (!urlMatch)
                         return false;
                     if (modelId && listConfig.modelIdField) {
-                        const rawModelId = wh[listConfig.modelIdField];
+                        const rawModelId = getByPath(wh, listConfig.modelIdField);
                         return (typeof rawModelId === 'string' ? rawModelId : '') === modelId;
                     }
                     return true;
                 });
                 if (matching) {
-                    const webhookId = String(matching[listConfig.idField]);
+                    const webhookId = String(getByPath(matching, listConfig.idField));
                     log.info(`Found existing webhook (ID: ${webhookId}), reusing`);
                     return { registered: true, webhookId, lastAttempt: now };
                 }
                 // Clean up stale webhooks (matching model but wrong callback URL)
                 if (modelId && listConfig.modelIdField && this.config.unregister) {
-                    const stale = existingWebhooks.filter(wh => {
-                        const rawModelId = wh[listConfig.modelIdField];
+                    const stale = existingWebhooks.filter((wh) => {
+                        const rawModelId = getByPath(wh, listConfig.modelIdField);
                         const whModelId = typeof rawModelId === 'string' ? rawModelId : '';
-                        const rawUrl = wh[listConfig.callbackUrlField];
+                        const rawUrl = getByPath(wh, listConfig.callbackUrlField);
                         const whCallbackUrl = typeof rawUrl === 'string' ? rawUrl : '';
                         return whModelId === modelId && whCallbackUrl !== callbackUrl;
                     });
                     for (const staleWh of stale) {
-                        const staleId = String(staleWh[listConfig.idField]);
+                        const staleId = String(getByPath(staleWh, listConfig.idField));
                         log.info(`Cleaning up stale webhook (ID: ${staleId})`);
                         try {
                             await this.unregister(staleId);

package/dist/remote/server.d.ts

@@ -12,6 +12,7 @@
  *   - Maintains an audit log of all operations
  *   - Rate-limits requests per session
  */
+import express from 'express';
 import { type RemoteServerConfig, type ResolvedRoute } from '../shared/config.js';
 import { EncryptedChannel, type PublicKeyBundle } from '../shared/crypto/index.js';
 import { HandshakeResponder, type HandshakeInit } from '../shared/protocol/index.js';
@@ -43,13 +44,25 @@ export interface PendingHandshake {
     init: HandshakeInit;
     createdAt: number;
 }
-export declare function isEndpointAllowed(url: string, patterns: string[]): boolean;
+/** Sanitized session projection — never includes channel keys or resolved
+ *  routes (which carry decrypted secrets). Returned by getSessionsSnapshot()
+ *  for the read-only /admin API. */
+export interface SessionSnapshot {
+    /** First 12 chars of the session ID — enough to disambiguate, doesn't
+     *  expose enough material to forge or replay encrypted requests. */
+    sessionIdShort: string;
+    callerAlias: string;
+    createdAt: number;
+    lastActivity: number;
+    requestCount: number;
+    windowRequests: number;
+    windowStart: number;
+}
+/** Loopback guard — used by /sync/listen, /sync/status, /events/stream, /admin.
+ *  Hoisted to module scope so the admin router and its tests can reuse it. */
+export declare function requireLoopback(req: express.Request, res: express.Response, next: express.NextFunction): void;
 export { resolvePlaceholders } from '../shared/config.js';
-/**
- * Find the first route whose allowedEndpoints match the given URL.
- * Routes with empty allowedEndpoints match nothing.
- */
-export declare function matchRoute(url: string, routes: ResolvedRoute[]): ResolvedRoute | null;
+export { toolHandlers, executeProxyRequest, isEndpointAllowed, matchRoute, type ToolContext, type ProxyRequestInput, type ProxyRequestResult, type FileAttachment, } from './tool-dispatch.js';
 export declare function checkRateLimit(session: Pick<Session, 'windowRequests' | 'windowStart'>, limit: number): boolean;
 export declare const SESSION_TTL: number;
 export declare const HANDSHAKE_TTL: number;
@@ -57,36 +70,13 @@ export declare function cleanupSessions(sessionsMap: Map<string, Pick<Session, '
     expiredSessions: string[];
     expiredHandshakes: string[];
 };
-export interface ProxyRequestInput {
-    method: string;
-    url: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-}
-export interface ProxyRequestResult {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: unknown;
-}
 /**
- * Core proxy request execution — route matching, secret injection, and fetch.
+ * Project the active sessions into a sanitized snapshot for read-only use.
  *
- * Used by:
- * - The remote server's `http_request` tool handler (this file)
- * - callboard's `LocalProxy` class (in-process, no encryption)
- *
- * Pure in the sense that it takes routes as input rather than reading global state.
- * The only side effect is the outbound fetch().
+ * Drops `channel` (holds AES keys) and `resolvedRoutes` (carry decrypted
+ * secrets). Used by the loopback /admin API; never call res.json(session).
  */
-export declare function executeProxyRequest(input: ProxyRequestInput, routes: ResolvedRoute[]): Promise<ProxyRequestResult>;
-/** Context passed to every tool handler, providing caller identity and shared services. */
-export interface ToolContext {
-    /** The caller alias for the session making this request. */
-    callerAlias: string;
-    /** The shared ingestor manager (for poll_events / ingestor_status). */
-    ingestorManager: IngestorManager;
-}
+export declare function getSessionsSnapshot(): SessionSnapshot[];
 /** Options for creating the app — allows dependency injection for tests */
 export interface CreateAppOptions {
     /** Override config instead of loading from disk */
@@ -97,6 +87,8 @@ export interface CreateAppOptions {
     authorizedPeers?: AuthorizedPeer[];
     /** Override the ingestor manager instead of creating one from config */
     ingestorManager?: IngestorManager;
+    /** Disable per-IP rate limiting (for tests that make many requests from localhost) */
+    disableRateLimiting?: boolean;
 }
 export declare function createApp(options?: CreateAppOptions): import("express-serve-static-core").Express;
 export declare function main(): void;