@wolpertingerlabs/drawlatch 1.0.0-alpha.10.0 → 1.0.0-alpha.15.0

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",
@@ -13,7 +13,8 @@
   },
   "secrets": {
     "GITHUB_TOKEN": "${GITHUB_TOKEN}",
-    "GITHUB_WEBHOOK_SECRET": "${GITHUB_WEBHOOK_SECRET}"
+    "GITHUB_WEBHOOK_SECRET": "${GITHUB_WEBHOOK_SECRET}",
+    "GITHUB_WEBHOOK_URL": "${GITHUB_WEBHOOK_URL}"
   },
   "allowedEndpoints": ["https://api.github.com/**"],
   "ingestor": {
@@ -21,7 +22,51 @@
     "webhook": {
       "path": "github",
       "signatureHeader": "X-Hub-Signature-256",
-      "signatureSecret": "GITHUB_WEBHOOK_SECRET"
+      "signatureSecret": "GITHUB_WEBHOOK_SECRET",
+      "callbackUrl": "${GITHUB_WEBHOOK_URL}",
+      "lifecycle": {
+        "list": {
+          "method": "GET",
+          "url": "https://api.github.com/repos/${repoFilter}/hooks",
+          "headers": {
+            "Authorization": "Bearer ${GITHUB_TOKEN}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28"
+          },
+          "callbackUrlField": "config.url",
+          "idField": "id"
+        },
+        "register": {
+          "method": "POST",
+          "url": "https://api.github.com/repos/${repoFilter}/hooks",
+          "headers": {
+            "Authorization": "Bearer ${GITHUB_TOKEN}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28"
+          },
+          "body": {
+            "name": "web",
+            "active": true,
+            "events": ["push", "pull_request", "issues", "issue_comment", "create", "delete", "release", "workflow_run", "check_run"],
+            "config": {
+              "url": "${GITHUB_WEBHOOK_URL}",
+              "content_type": "json",
+              "secret": "${GITHUB_WEBHOOK_SECRET}",
+              "insecure_ssl": "0"
+            }
+          },
+          "idField": "id"
+        },
+        "unregister": {
+          "method": "DELETE",
+          "url": "https://api.github.com/repos/${repoFilter}/hooks/${_webhookId}",
+          "headers": {
+            "Authorization": "Bearer ${GITHUB_TOKEN}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28"
+          }
+        }
+      }
     }
   },
   "testIngestor": {
@@ -37,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/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

@@ -43,6 +43,10 @@ export declare class IngestorManager {
     private readonly config;
     /** Active ingestor instances, keyed by `callerAlias:connectionAlias:instanceId`. */
     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.
@@ -63,6 +67,12 @@ export declare class IngestorManager {
      * 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.
      */
@@ -82,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).