@supaku/agentfactory-server 0.7.10 → 0.7.11

package/dist/src/governor-dedup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Redis Event Deduplicator
+ *
+ * Production EventDeduplicator backed by Redis SETNX with TTL.
+ * Key pattern: `governor:dedup:{dedupKey}`
+ */
+import type { EventDeduplicator, EventDeduplicatorConfig } from '@supaku/agentfactory';
+export declare class RedisEventDeduplicator implements EventDeduplicator {
+    private readonly windowMs;
+    private readonly keyPrefix;
+    constructor(config?: Partial<EventDeduplicatorConfig>, keyPrefix?: string);
+    isDuplicate(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=governor-dedup.d.ts.map

package/dist/src/governor-dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-dedup.d.ts","sourceRoot":"","sources":["../../src/governor-dedup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAQtF,qBAAa,sBAAuB,YAAW,iBAAiB;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAGhC,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM,EAC7C,SAAS,SAAmB;IAMxB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}

package/dist/src/governor-dedup.js

@@ -0,0 +1,31 @@
+/**
+ * Redis Event Deduplicator
+ *
+ * Production EventDeduplicator backed by Redis SETNX with TTL.
+ * Key pattern: `governor:dedup:{dedupKey}`
+ */
+import { DEFAULT_DEDUP_CONFIG } from '@supaku/agentfactory';
+import { redisSetNX } from './redis.js';
+// ---------------------------------------------------------------------------
+// RedisEventDeduplicator
+// ---------------------------------------------------------------------------
+export class RedisEventDeduplicator {
+    windowMs;
+    keyPrefix;
+    constructor(config = {}, keyPrefix = 'governor:dedup') {
+        this.windowMs = config.windowMs ?? DEFAULT_DEDUP_CONFIG.windowMs;
+        this.keyPrefix = keyPrefix;
+    }
+    async isDuplicate(key) {
+        const redisKey = `${this.keyPrefix}:${key}`;
+        const ttlSeconds = Math.max(1, Math.ceil(this.windowMs / 1000));
+        // SETNX returns true if key was newly set (not a duplicate)
+        const wasSet = await redisSetNX(redisKey, '1', ttlSeconds);
+        return !wasSet; // if we couldn't set, it's a duplicate
+    }
+    async clear() {
+        // In production, keys auto-expire via TTL.
+        // Explicit clear is mainly for testing — not implemented for Redis
+        // since test suites should use InMemoryEventDeduplicator.
+    }
+}

package/dist/src/governor-event-bus.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Redis Event Bus
+ *
+ * Production GovernorEventBus backed by Redis Streams.
+ * Uses a consumer group for reliable delivery and horizontal scaling.
+ *
+ * Stream: `governor:events`
+ * Consumer group: `governor-group`
+ * MAXLEN: 10,000 (approximate trim)
+ */
+import type { GovernorEvent, GovernorEventBus } from '@supaku/agentfactory';
+export interface RedisEventBusConfig {
+    /** Redis stream key (default: 'governor:events') */
+    streamKey?: string;
+    /** Consumer group name (default: 'governor-group') */
+    groupName?: string;
+    /** Consumer name within the group (default: hostname or random) */
+    consumerName?: string;
+    /** Max stream length — approximate trim (default: 10000) */
+    maxLen?: number;
+    /** Block timeout in milliseconds for XREADGROUP (default: 5000) */
+    blockMs?: number;
+}
+export declare class RedisEventBus implements GovernorEventBus {
+    private readonly streamKey;
+    private readonly groupName;
+    private readonly consumerName;
+    private readonly maxLen;
+    private readonly blockMs;
+    private closed;
+    private groupCreated;
+    constructor(config?: RedisEventBusConfig);
+    /**
+     * Ensure the consumer group exists. Idempotent — safe to call multiple times.
+     */
+    private ensureGroup;
+    publish(event: GovernorEvent): Promise<string>;
+    subscribe(): AsyncGenerator<{
+        id: string;
+        event: GovernorEvent;
+    }>;
+    ack(eventId: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Re-deliver pending messages (claimed but not acked from a previous run).
+     */
+    private readPending;
+    /**
+     * Parse a Redis stream message fields array into a GovernorEvent.
+     * Fields come as [key1, val1, key2, val2, ...].
+     */
+    private parseEvent;
+}
+//# sourceMappingURL=governor-event-bus.d.ts.map

package/dist/src/governor-event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-event-bus.d.ts","sourceRoot":"","sources":["../../src/governor-event-bus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAO3E,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAWD,qBAAa,aAAc,YAAW,gBAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAQ;gBAEhB,MAAM,GAAE,mBAAwB;IAQ5C;;OAEG;YACW,WAAW;IAenB,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B7C,SAAS,IAAI,cAAc,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC;IAiDlE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;YACY,WAAW;IAiC1B;;;OAGG;IACH,OAAO,CAAC,UAAU;CAanB"}

package/dist/src/governor-event-bus.js

@@ -0,0 +1,152 @@
+/**
+ * Redis Event Bus
+ *
+ * Production GovernorEventBus backed by Redis Streams.
+ * Uses a consumer group for reliable delivery and horizontal scaling.
+ *
+ * Stream: `governor:events`
+ * Consumer group: `governor-group`
+ * MAXLEN: 10,000 (approximate trim)
+ */
+import { getRedisClient } from './redis.js';
+const DEFAULT_STREAM_KEY = 'governor:events';
+const DEFAULT_GROUP_NAME = 'governor-group';
+const DEFAULT_MAX_LEN = 10_000;
+const DEFAULT_BLOCK_MS = 5_000;
+// ---------------------------------------------------------------------------
+// RedisEventBus
+// ---------------------------------------------------------------------------
+export class RedisEventBus {
+    streamKey;
+    groupName;
+    consumerName;
+    maxLen;
+    blockMs;
+    closed = false;
+    groupCreated = false;
+    constructor(config = {}) {
+        this.streamKey = config.streamKey ?? DEFAULT_STREAM_KEY;
+        this.groupName = config.groupName ?? DEFAULT_GROUP_NAME;
+        this.consumerName = config.consumerName ?? `governor-${process.pid}-${Date.now()}`;
+        this.maxLen = config.maxLen ?? DEFAULT_MAX_LEN;
+        this.blockMs = config.blockMs ?? DEFAULT_BLOCK_MS;
+    }
+    /**
+     * Ensure the consumer group exists. Idempotent — safe to call multiple times.
+     */
+    async ensureGroup() {
+        if (this.groupCreated)
+            return;
+        const redis = getRedisClient();
+        try {
+            await redis.xgroup('CREATE', this.streamKey, this.groupName, '0', 'MKSTREAM');
+        }
+        catch (err) {
+            // BUSYGROUP = group already exists, which is fine
+            if (err instanceof Error && !err.message.includes('BUSYGROUP')) {
+                throw err;
+            }
+        }
+        this.groupCreated = true;
+    }
+    async publish(event) {
+        if (this.closed) {
+            throw new Error('Event bus is closed');
+        }
+        const redis = getRedisClient();
+        const payload = JSON.stringify(event);
+        // XADD with approximate MAXLEN trim
+        const id = await redis.xadd(this.streamKey, 'MAXLEN', '~', String(this.maxLen), '*', 'data', payload);
+        if (!id) {
+            throw new Error('XADD returned null — stream write failed');
+        }
+        return id;
+    }
+    async *subscribe() {
+        await this.ensureGroup();
+        const redis = getRedisClient();
+        // First, re-deliver any pending messages (from previous crash)
+        yield* this.readPending(redis);
+        // Then read new messages
+        while (!this.closed) {
+            try {
+                const results = await redis.xreadgroup('GROUP', this.groupName, this.consumerName, 'COUNT', '1', 'BLOCK', this.blockMs, 'STREAMS', this.streamKey, '>');
+                if (!results || results.length === 0) {
+                    continue; // timeout, loop back
+                }
+                for (const [, messages] of results) {
+                    for (const [id, fields] of messages) {
+                        const event = this.parseEvent(fields);
+                        if (event) {
+                            yield { id, event };
+                        }
+                        else {
+                            // Malformed event — ack and skip
+                            await this.ack(id);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (this.closed)
+                    return;
+                // Log and continue on transient errors
+                console.error('[redis-event-bus] Error reading from stream:', err);
+                // Brief backoff before retry
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+        }
+    }
+    async ack(eventId) {
+        const redis = getRedisClient();
+        await redis.xack(this.streamKey, this.groupName, eventId);
+    }
+    async close() {
+        this.closed = true;
+    }
+    // ---- Internal ----
+    /**
+     * Re-deliver pending messages (claimed but not acked from a previous run).
+     */
+    async *readPending(redis) {
+        try {
+            const results = await redis.xreadgroup('GROUP', this.groupName, this.consumerName, 'COUNT', '100', 'STREAMS', this.streamKey, '0');
+            if (!results || results.length === 0)
+                return;
+            for (const [, messages] of results) {
+                for (const [id, fields] of messages) {
+                    if (!fields || fields.length === 0)
+                        continue; // already acked
+                    const event = this.parseEvent(fields);
+                    if (event) {
+                        yield { id, event };
+                    }
+                    else {
+                        await this.ack(id);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[redis-event-bus] Error reading pending messages:', err);
+        }
+    }
+    /**
+     * Parse a Redis stream message fields array into a GovernorEvent.
+     * Fields come as [key1, val1, key2, val2, ...].
+     */
+    parseEvent(fields) {
+        try {
+            // Find the 'data' field
+            for (let i = 0; i < fields.length; i += 2) {
+                if (fields[i] === 'data') {
+                    return JSON.parse(fields[i + 1]);
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/src/index.d.ts

@@ -16,4 +16,6 @@ export * from './token-storage.js';
 export * from './env-validation.js';
 export * from './governor-storage.js';
 export * from './processing-state-storage.js';
+export * from './governor-event-bus.js';
+export * from './governor-dedup.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA;AAG7C,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA"}

package/dist/src/index.js

@@ -34,3 +34,7 @@ export * from './env-validation.js';
 export * from './governor-storage.js';
 // Processing state storage (Redis-backed top-of-funnel phase tracking)
 export * from './processing-state-storage.js';
+// Governor event bus (Redis Streams)
+export * from './governor-event-bus.js';
+// Governor event deduplicator (Redis SETNX)
+export * from './governor-dedup.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supaku/agentfactory-server",
-  "version": "0.7.10",
+  "version": "0.7.11",
   "type": "module",
   "description": "Webhook server and distributed worker pool for AgentFactory — Redis queues, issue locks, session management",
   "author": "Supaku (https://supaku.com)",
@@ -44,8 +44,8 @@
   ],
   "dependencies": {
     "ioredis": "^5.4.2",
-    "@supaku/agentfactory-linear": "0.7.10",
-    "@supaku/agentfactory": "0.7.10"
+    "@supaku/agentfactory": "0.7.11",
+    "@supaku/agentfactory-linear": "0.7.11"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",