@wolpertingerlabs/drawlatch 1.0.0-alpha.12.0 → 1.0.0-alpha.15.2

package/bin/drawlatch.js

@@ -81,6 +81,7 @@ try {
       follow: { type: "boolean", default: false },
       path: { type: "boolean", default: false },
       full: { type: "boolean", default: false },
+      requests: { type: "boolean", default: false },
       ttl: { type: "string", default: "300" },
     },
     strict: false,
@@ -185,6 +186,13 @@ switch (subcommand) {
       await cmdSync();
     }
     break;
+  case "watch":
+    if (values.help) {
+      printWatchHelp();
+    } else {
+      await cmdWatch();
+    }
+    break;
   case "help":
     printHelp();
     {
@@ -477,39 +485,154 @@ async function cmdLogs() {
 
   const lines = parseInt(values.lines, 10) || 50;
   const follow = values.follow;
+  const showRequests = values.requests;
 
   const tailArgs = follow
     ? ["-n", String(lines), "-f", LOG_FILE]
     : ["-n", String(lines), LOG_FILE];
 
-  const tail = spawn("tail", tailArgs, { stdio: "inherit" });
+  if (showRequests) {
+    // Show everything — pipe directly to stdout
+    const tail = spawn("tail", tailArgs, { stdio: "inherit" });
 
-  tail.on("error", () => {
-    // Fallback: read last N lines with Node.js if tail is not available
-    try {
-      const content = readFileSync(LOG_FILE, "utf-8");
-      const allLines = content.split("\n");
-      const lastLines = allLines.slice(-lines).join("\n");
-      console.log(lastLines);
-      if (follow) {
-        console.log(
-          "\n(Live following not available \u2014 'tail' command not found)",
-        );
-      }
-    } catch (err) {
-      console.error(`Error reading log file: ${err.message}`);
-      process.exit(1);
+    tail.on("error", () => logsFallback(lines, follow, null));
+
+    process.on("SIGINT", () => {
+      tail.kill();
+      process.exit(0);
+    });
+
+    await new Promise((res) => tail.on("close", res));
+  } else {
+    // Filter out [audit] lines (request/response noise from poll_events etc.)
+    const tail = spawn("tail", tailArgs, { stdio: ["ignore", "pipe", "inherit"] });
+    const grepProc = spawn("grep", ["-v", "^\\[audit\\]"], {
+      stdio: [tail.stdout, "inherit", "inherit"],
+    });
+
+    tail.on("error", () => logsFallback(lines, follow, "[audit]"));
+
+    process.on("SIGINT", () => {
+      tail.kill();
+      grepProc.kill();
+      process.exit(0);
+    });
+
+    await new Promise((res) => grepProc.on("close", res));
+  }
+}
+
+function logsFallback(lines, follow, filterPrefix) {
+  try {
+    const content = readFileSync(LOG_FILE, "utf-8");
+    let allLines = content.split("\n");
+    if (filterPrefix) {
+      allLines = allLines.filter((l) => !l.startsWith(filterPrefix));
     }
-  });
+    const lastLines = allLines.slice(-lines).join("\n");
+    console.log(lastLines);
+    if (follow) {
+      console.log(
+        "\n(Live following not available \u2014 'tail' command not found)",
+      );
+    }
+  } catch (err) {
+    console.error(`Error reading log file: ${err.message}`);
+    process.exit(1);
+  }
+}
 
-  // Forward SIGINT to cleanly exit
+async function cmdWatch() {
+  const config = loadRemoteConfig();
+  const port = config.port;
+  const host = config.host;
+
+  // Verify the server is running
+  const healthy = await healthCheck(host, port);
+  if (!healthy) {
+    console.error("Remote server is not running. Start it first:");
+    console.error("  drawlatch start");
+    process.exit(1);
+  }
+
+  const showFull = values.full;
+  const sourceFilter = positionals[0] || null;
+
+  console.log("Watching for events" + (sourceFilter ? ` from "${sourceFilter}"` : "") + "...");
+  console.log("Press Ctrl+C to stop.\n");
+
+  const controller = new AbortController();
   process.on("SIGINT", () => {
-    tail.kill();
+    controller.abort();
     process.exit(0);
   });
 
-  // Wait for tail to exit (when using --no-follow)
-  await new Promise((res) => tail.on("close", res));
+  try {
+    const res = await fetch(
+      `http://${connectHost(host)}:${port}/events/stream`,
+      { signal: controller.signal },
+    );
+
+    if (!res.ok) {
+      console.error(`Failed to connect to event stream: HTTP ${res.status}`);
+      process.exit(1);
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    for await (const chunk of res.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+
+      // Parse SSE lines
+      let newlineIdx;
+      while ((newlineIdx = buffer.indexOf("\n\n")) !== -1) {
+        const message = buffer.slice(0, newlineIdx);
+        buffer = buffer.slice(newlineIdx + 2);
+
+        for (const line of message.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+
+          try {
+            const event = JSON.parse(line.slice(6));
+
+            // Apply source filter if set
+            if (sourceFilter && event.source !== sourceFilter) continue;
+
+            const time = new Date(event.receivedAt).toLocaleTimeString();
+            const source = event.source;
+            const instance = event.instanceId ? `:${event.instanceId}` : "";
+            const caller = event.callerAlias || "?";
+            const eventType = event.eventType;
+
+            const dataStr = JSON.stringify(event.data);
+
+            if (showFull) {
+              console.log(
+                `\x1b[2m${time}\x1b[0m \x1b[36m${source}${instance}\x1b[0m \x1b[33m${eventType}\x1b[0m \x1b[2m(${caller})\x1b[0m`
+              );
+              console.log(dataStr);
+              console.log("");
+            } else {
+              const preview =
+                dataStr.length > 100
+                  ? dataStr.slice(0, 100) + "…"
+                  : dataStr;
+              console.log(
+                `\x1b[2m${time}\x1b[0m \x1b[36m${source}${instance}\x1b[0m \x1b[33m${eventType}\x1b[0m \x1b[2m(${caller})\x1b[0m ${preview}`
+              );
+            }
+          } catch {
+            // Skip malformed SSE data
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (err.name === "AbortError") return;
+    console.error(`Event stream error: ${err.message}`);
+    process.exit(1);
+  }
 }
 
 function cmdConfig() {
@@ -1126,6 +1249,7 @@ Commands:
   status             Show server status (PID, port, uptime, health, sessions)
   logs               View and follow remote server logs
   config             Show effective configuration
+  watch              Watch ingestor events in real time
   doctor             Validate setup and diagnose issues
   generate-keys      Generate Ed25519 + X25519 keypairs
   sync               Exchange keys with a callboard instance
@@ -1220,19 +1344,42 @@ function printLogsHelp() {
   console.log(`
 drawlatch logs
 
-View server logs.
+View server logs (request/response audit lines are hidden by default).
 
 Usage: drawlatch logs [options]
 
 Options:
   -n, --lines <number>  Number of lines to show (default: 50)
   --follow               Follow/tail the log output (default: print and exit)
+  --requests             Include request/response audit lines (noisy with polling)
   -h, --help             Show this help message
 
 Log file: ~/.drawlatch/logs/drawlatch.log
 `);
 }
 
+function printWatchHelp() {
+  console.log(`
+drawlatch watch
+
+Watch ingestor events in real time.
+
+Usage: drawlatch watch [source] [options]
+
+Arguments:
+  source                 Filter to a specific connection (e.g., "discord-bot", "github")
+
+Options:
+  --full                 Show full event payload (default: truncate to 100 chars)
+  -h, --help             Show this help message
+
+Examples:
+  drawlatch watch                     Watch all events
+  drawlatch watch github              Watch only GitHub events
+  drawlatch watch discord-bot --full  Watch Discord events with full payloads
+`);
+}
+
 function printConfigHelp() {
   console.log(`
 drawlatch config

package/dist/connections/developer-tools/github.json

@@ -1,6 +1,6 @@
 {
   "name": "GitHub API",
-  "stability": "beta",
+  "stability": "stable",
   "category": "developer-tools",
   "description": "GitHub REST API — repositories, issues, pull requests, users, organizations, and more. Auth is handled automatically via the GITHUB_TOKEN environment variable. Includes a webhook ingestor for real-time events (push, pull_request, issues, etc.) — set GITHUB_WEBHOOK_SECRET and use poll_events to retrieve them.",
   "docsUrl": "https://docs.github.com/en/rest",
@@ -49,7 +49,7 @@
             "active": true,
             "events": ["push", "pull_request", "issues", "issue_comment", "create", "delete", "release", "workflow_run", "check_run"],
             "config": {
-              "url": "${GITHUB_WEBHOOK_URL}/webhooks/github",
+              "url": "${GITHUB_WEBHOOK_URL}",
               "content_type": "json",
               "secret": "${GITHUB_WEBHOOK_SECRET}",
               "insecure_ssl": "0"
@@ -82,12 +82,21 @@
       {
         "key": "repoFilter",
         "label": "Repository Filter",
-        "description": "Only capture webhook events from these repositories (owner/repo format). Leave empty for all.",
+        "description": "Register a repo-level webhook and only capture events from this repository (owner/repo format). Mutually exclusive with Organization for registration.",
         "type": "text[]",
         "instanceKey": true,
         "placeholder": "e.g., octocat/Hello-World",
         "group": "Filtering"
       },
+      {
+        "key": "orgFilter",
+        "label": "Organization",
+        "description": "Register an org-level webhook that receives events from all repos in the organization. Mutually exclusive with Repository Filter for registration.",
+        "type": "text",
+        "instanceKey": true,
+        "placeholder": "e.g., my-org",
+        "group": "Filtering"
+      },
       {
         "key": "eventFilter",
         "label": "Event Types",

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

@@ -45,6 +45,8 @@ export declare class IngestorManager {
     private ingestors;
     /** 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.
@@ -90,6 +92,15 @@ export declare class IngestorManager {
      * Get status of all ingestors for a caller.
      */
     getStatuses(callerAlias: string): IngestorStatus[];
+    /**
+     * 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).

package/dist/remote/ingestors/manager.js

@@ -51,6 +51,8 @@ export class IngestorManager {
     ingestors = new Map();
     /** 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.
@@ -142,6 +144,11 @@ export class IngestorManager {
             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();
@@ -250,6 +257,28 @@ export class IngestorManager {
         }
         return statuses;
     }
+    /**
+     * 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).
@@ -362,6 +391,11 @@ export class IngestorManager {
         }
         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();
@@ -545,6 +579,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/webhook/github-webhook-ingestor.d.ts

@@ -19,12 +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 repository name for multi-instance webhook lifecycle management.
-     * Enables the lifecycle manager to match and clean up stale webhooks per-repo.
+     * 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,19 +23,58 @@ 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 repository name for multi-instance webhook lifecycle management.
-     * Enables the lifecycle manager to match and clean up stale webhooks per-repo.
+     * 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.
      * When repoFilter is set, only events from those repos are accepted.

package/dist/remote/server.js

@@ -1427,6 +1427,23 @@ export function createApp(options = {}) {
             uptime: process.uptime(),
         });
     });
+    // ── Event stream (loopback-only, for `drawlatch watch`) ─────────────
+    app.get('/events/stream', requireLoopback, (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        });
+        res.flushHeaders();
+        const mgr = app.locals.ingestorManager;
+        const listener = (event) => {
+            res.write(`data: ${JSON.stringify(event)}\n\n`);
+        };
+        mgr.onEvent(listener);
+        req.on('close', () => {
+            mgr.offEvent(listener);
+        });
+    });
     // ── Webhook receiver ─────────────────────────────────────────────────
     // Trello (and potentially other services) send a HEAD request to the
     // callback URL to verify it is reachable before activating the webhook.
@@ -1476,6 +1493,8 @@ export function createApp(options = {}) {
     });
     return app;
 }
+// waitForTunnelReady is now exported from tunnel.ts — imported dynamically
+// alongside startTunnel in the tunnel startup block below.
 // ── Start ──────────────────────────────────────────────────────────────────
 export function main() {
     console.log('[remote] Starting drawlatch server...');
@@ -1520,7 +1539,7 @@ export function main() {
         // process.env.DRAWLATCH_TUNNEL_URL is available during secret resolution.
         if (useTunnel) {
             try {
-                const { startTunnel } = await import('./tunnel.js');
+                const { startTunnel, waitForTunnelReady } = await import('./tunnel.js');
                 const tunnel = await startTunnel({ port, host });
                 stopTunnel = tunnel.stop;
                 process.env.DRAWLATCH_TUNNEL_URL = tunnel.url;
@@ -1537,16 +1556,29 @@ export function main() {
                         const match = /^\$\{(\w+)\}$/.exec(callbackTpl);
                         if (match) {
                             const envVar = match[1];
+                            const fullUrl = `${tunnel.url}/webhooks/${webhookPath}`;
+                            // Set bare env var
                             if (!process.env[envVar]) {
-                                const fullUrl = `${tunnel.url}/webhooks/${webhookPath}`;
                                 process.env[envVar] = fullUrl;
                                 console.log(`[remote] Auto-set ${envVar}=${fullUrl}`);
                             }
+                            // Also set prefixed env var so caller-scoped secret resolution
+                            // (which checks PREFIX_VAR, not bare VAR) can find it.
+                            const prefix = callerAlias.toUpperCase().replace(/-/g, '_');
+                            const prefixedEnvVar = `${prefix}_${envVar}`;
+                            if (!process.env[prefixedEnvVar]) {
+                                process.env[prefixedEnvVar] = fullUrl;
+                                console.log(`[remote] Auto-set ${prefixedEnvVar}=${fullUrl}`);
+                            }
                         }
                     }
                 }
                 console.log(`[remote] Tunnel active: ${tunnel.url}`);
                 console.log(`[remote] Webhook URL:   ${tunnel.url}/webhooks/<path>`);
+                // Wait for the tunnel to be fully connected before starting ingestors.
+                // cloudflared reports the URL before the QUIC connection is established;
+                // services like Trello validate the callback URL during registration.
+                await waitForTunnelReady(tunnel.url, 10_000);
             }
             catch (err) {
                 console.error('[remote] Failed to start tunnel:', err);

package/dist/remote/tunnel.d.ts

@@ -37,4 +37,17 @@ export declare function isCloudflaredAvailable(): Promise<boolean>;
  * emit a URL within the configured timeout.
  */
 export declare function startTunnel(options: TunnelOptions): Promise<TunnelResult>;
+/**
+ * Wait for a tunnel to be fully connected by probing a URL through it.
+ *
+ * cloudflared emits the tunnel URL before the QUIC connection is fully
+ * established. Services like Trello validate the callback URL at registration
+ * time, so callers should wait until the tunnel is actually reachable before
+ * starting webhook ingestors.
+ *
+ * @param tunnelUrl  The public tunnel URL to probe (e.g. https://abc.trycloudflare.com).
+ * @param timeoutMs  How long to wait before giving up (default: 10 000 ms).
+ * @param probePath  Path to probe on the tunnel (default: "/health").
+ */
+export declare function waitForTunnelReady(tunnelUrl: string, timeoutMs?: number, probePath?: string): Promise<void>;
 //# sourceMappingURL=tunnel.d.ts.map

package/dist/remote/tunnel.js

@@ -113,4 +113,37 @@ export async function startTunnel(options) {
         }
     });
 }
+// ── Tunnel readiness probe ──────────────────────────────────────────────
+/**
+ * Wait for a tunnel to be fully connected by probing a URL through it.
+ *
+ * cloudflared emits the tunnel URL before the QUIC connection is fully
+ * established. Services like Trello validate the callback URL at registration
+ * time, so callers should wait until the tunnel is actually reachable before
+ * starting webhook ingestors.
+ *
+ * @param tunnelUrl  The public tunnel URL to probe (e.g. https://abc.trycloudflare.com).
+ * @param timeoutMs  How long to wait before giving up (default: 10 000 ms).
+ * @param probePath  Path to probe on the tunnel (default: "/health").
+ */
+export async function waitForTunnelReady(tunnelUrl, timeoutMs = 10_000, probePath = '/health') {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const resp = await fetch(`${tunnelUrl}${probePath}`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(2000),
+            });
+            if (resp.ok) {
+                log.info('Tunnel connectivity verified');
+                return;
+            }
+        }
+        catch {
+            // Tunnel not ready yet — retry
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    log.warn('Tunnel readiness probe timed out — webhook registration may fail');
+}
 //# sourceMappingURL=tunnel.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wolpertingerlabs/drawlatch",
-  "version": "1.0.0-alpha.12.0",
+  "version": "1.0.0-alpha.15.2",
   "description": "Encrypted MCP proxy with mutual authentication. Local MCP server forwards requests through an encrypted channel to a remote secrets-holding server.",
   "type": "module",
   "main": "./dist/mcp/server.js",

package/dist/connections/developer-tools/github-events-poll.json

@@ -1,78 +0,0 @@
-{
-  "name": "GitHub Events API (Poll)",
-  "stability": "beta",
-  "category": "developer-tools",
-  "description": "GitHub Events REST API — polls repository events for push, pull_request, issues, and more. A webhook-free alternative to the GitHub webhook connection. Auth is handled automatically via the GITHUB_TOKEN environment variable. Uses ETag caching to minimize rate limit consumption. Use poll_events to retrieve buffered events.",
-  "docsUrl": "https://docs.github.com/en/rest/activity/events",
-  "headers": {
-    "Authorization": "Bearer ${GITHUB_TOKEN}",
-    "Accept": "application/vnd.github+json",
-    "X-GitHub-Api-Version": "2022-11-28",
-    "User-Agent": "drawlatch"
-  },
-  "secrets": {
-    "GITHUB_TOKEN": "${GITHUB_TOKEN}"
-  },
-  "allowedEndpoints": ["https://api.github.com/**"],
-  "ingestor": {
-    "type": "poll",
-    "poll": {
-      "url": "https://api.github.com/repos/${GITHUB_POLL_REPO}/events",
-      "intervalMs": 60000,
-      "method": "GET",
-      "deduplicateBy": "id",
-      "eventType": "github_event",
-      "etag": true
-    }
-  },
-  "testIngestor": {
-    "description": "Executes a single poll of the repository events endpoint to verify access",
-    "strategy": "poll_once",
-    "request": {
-      "method": "GET",
-      "url": "https://api.github.com/repos/${GITHUB_POLL_REPO}/events?per_page=1",
-      "expectedStatus": [200]
-    }
-  },
-  "listenerConfig": {
-    "name": "GitHub Events Poll Listener",
-    "description": "Polls the GitHub Events API for repository activity. A webhook-free alternative — ideal for environments without a public URL.",
-    "supportsMultiInstance": true,
-    "fields": [
-      {
-        "key": "GITHUB_POLL_REPO",
-        "label": "Repository",
-        "description": "Repository to poll for events (owner/repo format).",
-        "type": "text",
-        "instanceKey": true,
-        "overrideKey": "GITHUB_POLL_REPO",
-        "placeholder": "e.g., octocat/Hello-World",
-        "group": "Connection"
-      },
-      {
-        "key": "intervalMs",
-        "label": "Poll Interval (ms)",
-        "description": "How often to check for new events, in milliseconds. GitHub caches events for ~60s, so polling faster is wasteful.",
-        "type": "number",
-        "default": 60000,
-        "min": 30000,
-        "max": 3600000,
-        "group": "Connection"
-      },
-      {
-        "key": "bufferSize",
-        "label": "Buffer Size",
-        "description": "Maximum number of events to keep in memory.",
-        "type": "number",
-        "default": 200,
-        "min": 10,
-        "max": 1000,
-        "group": "Advanced"
-      }
-    ]
-  },
-  "testConnection": {
-    "url": "https://api.github.com/user",
-    "description": "Fetches the authenticated user profile"
-  }
-}