@teamvibe/poller 0.1.57 → 0.1.58

package/dist/auth-provider.js

@@ -1,5 +1,6 @@
 import { POLLER_VERSION } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 let currentCredentials = null;
 let currentConfig = null;
 let currentPollerId = null;
@@ -19,10 +20,12 @@ async function sendHeartbeat(apiUrl, token, version) {
         });
         if (!response.ok) {
             logger.warn(`Heartbeat failed (${response.status})`);
+            emitError('auth', `Heartbeat failed (${response.status})`, { severity: 'warn' });
         }
     }
     catch (error) {
         logger.warn(`Heartbeat error: ${error instanceof Error ? error.message : error}`);
+        emitError('auth', `Heartbeat error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
     }
 }
 async function fetchCredentials(apiUrl, token) {
@@ -62,6 +65,7 @@ export async function initAuth(apiUrl, token) {
         }
         catch (error) {
             logger.error(`Credential refresh failed: ${error instanceof Error ? error.message : error}`);
+            emitError('auth', `Credential refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }, REFRESH_INTERVAL_MS);
 }

package/dist/brain-manager.js

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 const execAsync = promisify(exec);
 // Clean env for git commands:
 // - npm/npx sets GIT_ASKPASS which prevents credential helpers from working
@@ -42,10 +43,12 @@ async function reportBrainSync(brainId, workspaceId, event) {
         });
         if (!response.ok) {
             logger.warn(`Brain sync report failed (${response.status})`);
+            emitError('brain', `Brain sync report failed (${response.status})`, { severity: 'warn', context: { brainId, event } });
         }
     }
     catch (error) {
         logger.warn(`Brain sync report error: ${error instanceof Error ? error.message : error}`);
+        emitError('brain', `Brain sync report error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn', context: { brainId } });
     }
 }
 export async function getBrainPath(brain, channelId, workspaceId) {
@@ -107,6 +110,7 @@ async function updateBrain(brainDir, brainId, branch) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.error(`Failed to update brain ${brainId}: ${errorMessage}`);
+        emitError('brain', `Failed to update brain ${brainId}: ${errorMessage}`, { context: { brainId, brainDir } });
     }
 }
 /**
@@ -170,6 +174,7 @@ export async function pushBrainChanges(brainDir, brainId, workspaceId) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.warn(`Failed to push brain ${brainId} changes: ${errorMessage}`);
+        emitError('brain', `Failed to push brain ${brainId} changes: ${errorMessage}`, { severity: 'warn', context: { brainId } });
     }
 }
 /**

package/dist/claude-spawner.js

@@ -6,6 +6,7 @@ import { config } from './config.js';
 import { logger } from './logger.js';
 import { getBaseBrainPath } from './brain-manager.js';
 import { getPollerId } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 /**
  * Maps tool names (or prefixes) to human-readable status messages.
  * More specific patterns are checked first.
@@ -80,6 +81,7 @@ async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
     }
     catch (error) {
         logger.warn(`Failed to count new thread messages: ${error}`);
+        emitError('slack', `Failed to count new thread messages: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
         return 0;
     }
 }
@@ -97,6 +99,7 @@ function readBrainSettings(cwd) {
     }
     catch (error) {
         logger.warn(`Failed to read brain settings at ${settingsPath}: ${error}`);
+        emitError('brain', `Failed to read brain settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
         return {};
     }
 }
@@ -373,6 +376,10 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         const timeout = setTimeout(() => {
             timedOut = true;
             logger.error(`Claude Code process timed out after ${timeoutMinutes} minutes`);
+            emitError('session', `Claude Code process timed out after ${timeoutMinutes} minutes`, {
+                context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                channelId: msg.teamvibe.channelId,
+            });
             proc.kill('SIGTERM');
             setTimeout(() => proc.kill('SIGKILL'), 5000);
         }, config.CLAUDE_TIMEOUT_MS);
@@ -395,6 +402,10 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         proc.on('error', (error) => {
             clearTimeout(timeout);
             activeProcesses.delete(msg.id);
+            emitError('session', `Claude Code process spawn error: ${error.message}`, {
+                channelId: msg.teamvibe.channelId,
+                context: { threadId: msg.thread_id },
+            });
             resolve({
                 success: false,
                 output: stdout,
@@ -440,6 +451,7 @@ export function killAllActiveProcesses() {
         }
         const forceKillTimer = setTimeout(() => {
             logger.warn(`Process ${id} did not exit after SIGTERM, sending SIGKILL`);
+            emitError('session', `Process ${id} did not exit after SIGTERM, sending SIGKILL`, { severity: 'warn' });
             proc.kill('SIGKILL');
         }, 5000);
         proc.once('close', () => {

package/dist/event-queue.d.ts

@@ -0,0 +1,14 @@
+export type ErrorCategory = 'sqs' | 'brain' | 'auth' | 'session' | 'slack' | 'maintenance';
+export type ErrorSeverity = 'warn' | 'error';
+export declare function flush(): Promise<void>;
+export declare function startEventQueue(): void;
+export declare function stopEventQueue(): void;
+export declare function emitError(category: ErrorCategory, message: string, options?: {
+    severity?: ErrorSeverity;
+    channelId?: string;
+    context?: Record<string, unknown>;
+}): void;
+/** For testing: get current queue length */
+export declare function getQueueLength(): number;
+/** For testing: clear the queue */
+export declare function clearQueue(): void;

package/dist/event-queue.js

@@ -0,0 +1,113 @@
+// packages/poller/src/event-queue.ts
+import { config } from './config.js';
+import { logger } from './logger.js';
+const MAX_QUEUE_SIZE = 200;
+const FLUSH_INTERVAL_MS = 30_000;
+const DEDUP_WINDOW_MS = 60_000;
+let queue = [];
+let flushTimer = null;
+let isFlushing = false;
+function dedupKey(channelId, category, message) {
+    return `${channelId}:${category}:${message}`;
+}
+function enqueue(event) {
+    // Dedup: collapse identical category+message within window
+    const key = dedupKey(event.channelId, event.metadata.category, event.metadata.message);
+    const now = Date.now();
+    const windowStart = new Date(now - DEDUP_WINDOW_MS).toISOString();
+    const existing = queue.find((e) => dedupKey(e.channelId, e.metadata.category, e.metadata.message) === key &&
+        e.timestamp >= windowStart);
+    if (existing) {
+        existing.metadata.count += 1;
+        return;
+    }
+    if (queue.length >= MAX_QUEUE_SIZE) {
+        queue.shift(); // Drop oldest
+    }
+    queue.push(event);
+}
+async function flushOne(event) {
+    try {
+        const response = await fetch(`${config.TEAMVIBE_API_URL}/events`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.TEAMVIBE_POLLER_TOKEN}`,
+            },
+            body: JSON.stringify({
+                eventType: event.eventType,
+                channelId: event.channelId,
+                metadata: event.metadata,
+                error: event.error,
+            }),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function flush() {
+    if (queue.length === 0 || isFlushing)
+        return;
+    isFlushing = true;
+    try {
+        const batch = [...queue];
+        const failed = [];
+        for (const event of batch) {
+            const ok = await flushOne(event);
+            if (!ok) {
+                failed.push(event);
+            }
+        }
+        queue = failed;
+        if (failed.length > 0) {
+            logger.debug(`[EventQueue] ${failed.length} event(s) failed to flush, will retry`);
+        }
+    }
+    finally {
+        isFlushing = false;
+    }
+}
+export function startEventQueue() {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return; // No-op in direct mode
+    }
+    flushTimer = setInterval(() => {
+        flush().catch(() => { });
+    }, FLUSH_INTERVAL_MS);
+}
+export function stopEventQueue() {
+    if (flushTimer) {
+        clearInterval(flushTimer);
+        flushTimer = null;
+    }
+}
+export function emitError(category, message, options) {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return; // No-op in direct mode
+    }
+    const severity = options?.severity ?? 'error';
+    const channelId = options?.channelId ?? '_system';
+    enqueue({
+        eventType: 'poller.error',
+        channelId,
+        metadata: {
+            category,
+            severity,
+            message,
+            count: 1,
+            context: options?.context,
+        },
+        error: { code: category, message },
+        timestamp: new Date().toISOString(),
+    });
+}
+/** For testing: get current queue length */
+export function getQueueLength() {
+    return queue.length;
+}
+/** For testing: clear the queue */
+export function clearQueue() {
+    queue = [];
+}

package/dist/heartbeat-manager.js

@@ -1,6 +1,7 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isAtCapacity } from './claude-spawner.js';
+import { emitError } from './event-queue.js';
 const trackedBrains = new Map();
 let heartbeatInterval = null;
 /**
@@ -85,6 +86,10 @@ export function startHeartbeatLoop(processMessageFn) {
             }
             catch (error) {
                 logger.error(`[Heartbeat] Failed maintenance for ${brainId}: ${error instanceof Error ? error.message : error}`);
+                emitError('session', `Heartbeat maintenance failed for ${brainId}: ${error instanceof Error ? error.message : String(error)}`, {
+                    channelId: info.channelId,
+                    context: { brainId },
+                });
             }
         }
     }, config.MAINTENANCE_CHECK_INTERVAL_MS);

package/dist/maintenance-reporter.js

@@ -4,6 +4,7 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 const execFileAsync = promisify(execFile);
 const OPERATION_TO_EVENT_TYPE = {
     consolidation: 'maintenance.consolidation',
@@ -32,11 +33,13 @@ export async function postMaintenanceReports(brainPath, channelId) {
                 const report = JSON.parse(content);
                 if (!report.operationType) {
                     logger.warn(`[MaintenanceReporter] Skipping ${file}: missing operationType`);
+                    emitError('maintenance', `Skipping report ${file}: missing operationType`, { severity: 'warn' });
                     continue;
                 }
                 const eventType = OPERATION_TO_EVENT_TYPE[report.operationType];
                 if (!eventType) {
                     logger.warn(`[MaintenanceReporter] Skipping ${file}: unknown operationType "${report.operationType}"`);
+                    emitError('maintenance', `Skipping report ${file}: unknown operationType "${report.operationType}"`, { severity: 'warn' });
                     continue;
                 }
                 const payload = {
@@ -60,10 +63,12 @@ export async function postMaintenanceReports(brainPath, channelId) {
                 else {
                     const errorBody = await response.text().catch(() => 'unknown');
                     logger.warn(`[MaintenanceReporter] Failed to POST ${file}: ${response.status} ${errorBody}`);
+                    emitError('maintenance', `Failed to POST report ${file}: ${response.status}`, { severity: 'warn', channelId });
                 }
             }
             catch (err) {
                 logger.warn(`[MaintenanceReporter] Error processing ${file}: ${err instanceof Error ? err.message : err}`);
+                emitError('maintenance', `Error processing report ${file}: ${err instanceof Error ? err.message : String(err)}`, { severity: 'warn', channelId });
             }
         }
         // Remove posted JSON reports from git so they don't resurrect on next pull
@@ -80,5 +85,6 @@ export async function postMaintenanceReports(brainPath, channelId) {
     }
     catch (err) {
         logger.warn(`[MaintenanceReporter] Error scanning reports: ${err instanceof Error ? err.message : err}`);
+        emitError('maintenance', `Error scanning reports: ${err instanceof Error ? err.message : String(err)}`, { severity: 'warn' });
     }
 }

package/dist/poller.js

@@ -8,6 +8,7 @@ import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } fr
 import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
+import { startEventQueue, stopEventQueue, flush as flushEventQueue } from './event-queue.js';
 // Track active message processing
 const processingMessages = new Set();
 // Per-thread completion signals
@@ -312,6 +313,7 @@ async function shutdown(signal) {
     logger.info(`${signal} received, shutting down gracefully...`);
     stopRefresh();
     stopHeartbeatLoop();
+    stopEventQueue();
     // Unblock all messages waiting on thread completion so they can exit
     for (const [threadId, signals] of threadCompletionSignals.entries()) {
         logger.info(`Unblocking ${signals.length} waiting message(s) on thread ${threadId}`);
@@ -332,6 +334,8 @@ async function shutdown(signal) {
         logger.info(`Waiting for ${processingMessages.size} message(s) to complete...`);
         await sleep(1000);
     }
+    // Final flush after all processes stopped — captures errors emitted during shutdown
+    await flushEventQueue();
     logger.info('Shutdown complete');
     process.exit(0);
 }
@@ -349,6 +353,7 @@ export async function startPoller() {
         logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
         logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
     }
+    startEventQueue();
     await ensureDirectories();
     await ensureBaseBrain();
     startHeartbeatLoop(processMessage);

package/dist/session-store.js

@@ -4,6 +4,7 @@ import { randomUUID } from 'crypto';
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 function createDocClient() {
     if (isTokenMode()) {
         const creds = getCredentials();
@@ -94,6 +95,7 @@ export async function acquireSessionLock(threadId, workspacePath) {
         const staleLockTimeout = config.STALE_LOCK_TIMEOUT_MS;
         if (lockAge > staleLockTimeout) {
             logger.warn(`Session ${threadId} has stale lock (age: ${Math.round(lockAge / 1000)}s), attempting recovery...`);
+            emitError('session', `Stale lock detected on session ${threadId} (age: ${Math.round(lockAge / 1000)}s)`, { severity: 'warn' });
             const released = await forceReleaseStalelock(threadId, staleLockTimeout);
             if (released) {
                 logger.info(`Stale lock released for ${threadId}, retrying acquisition`);
@@ -164,6 +166,7 @@ export async function updateSessionId(threadId, lockToken, newSessionId) {
     catch (error) {
         if (error.name === 'ConditionalCheckFailedException') {
             logger.warn(`Lock token mismatch when updating session_id for ${threadId}`);
+            emitError('session', `Lock token mismatch when updating session_id for ${threadId}`, { severity: 'warn' });
             return;
         }
         throw error;
@@ -201,6 +204,7 @@ export async function releaseSessionLock(threadId, lockToken, newStatus = 'idle'
     catch (error) {
         if (error.name === 'ConditionalCheckFailedException') {
             logger.warn(`Lock token mismatch when releasing session ${threadId}`);
+            emitError('session', `Lock token mismatch when releasing session ${threadId}`, { severity: 'warn' });
             return;
         }
         throw error;
@@ -232,6 +236,7 @@ export async function forceReleaseStalelock(threadId, maxAgeMs) {
             },
         }));
         logger.warn(`Force released stale lock on session ${threadId} (age: ${lockAge}ms)`);
+        emitError('session', `Force released stale lock on session ${threadId}`, { severity: 'warn' });
         return true;
     }
     catch (error) {

package/dist/slack-client.js

@@ -1,5 +1,6 @@
 import { WebClient } from '@slack/web-api';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 // Cache user info to avoid repeated API calls
 const userCache = new Map();
 // Per-token Slack client cache
@@ -34,6 +35,7 @@ export async function getUserInfo(botToken, userId) {
         }
         else {
             logger.warn(`Failed to fetch user info for ${userId}:`, error?.data?.error || error);
+            emitError('slack', `Failed to fetch user info for ${userId}`, { severity: 'warn' });
         }
     }
     const fallback = { name: userId, realName: userId };
@@ -84,6 +86,7 @@ export async function addReaction(msg, emoji) {
     }
     catch (error) {
         logger.warn(`Failed to add reaction ${emoji}:`, error);
+        emitError('slack', `Failed to add reaction ${emoji}`, { severity: 'warn' });
     }
 }
 export async function setThreadStatus(msg, status) {
@@ -100,6 +103,7 @@ export async function setThreadStatus(msg, status) {
     }
     catch (error) {
         logger.warn(`Failed to set thread status: ${error}`);
+        emitError('slack', `Failed to set thread status`, { severity: 'warn' });
     }
 }
 export function startTypingIndicator(msg, statusText = 'is thinking...') {

package/dist/sqs-poller.js

@@ -2,6 +2,7 @@ import { SQSClient, ReceiveMessageCommand, DeleteMessageCommand, ChangeMessageVi
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 function createSqsClient() {
     if (isTokenMode()) {
         const creds = getCredentials();
@@ -42,12 +43,14 @@ export async function pollMessages(maxMessages = 10) {
     }
     catch (error) {
         logger.error('Error polling SQS:', error);
+        emitError('sqs', `Error polling SQS: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }
 function parseMessage(msg) {
     if (!msg.Body || !msg.ReceiptHandle || !msg.MessageId) {
         logger.error('Invalid SQS message - missing required fields');
+        emitError('sqs', 'Invalid SQS message - missing required fields');
         return null;
     }
     try {
@@ -60,6 +63,7 @@ function parseMessage(msg) {
     }
     catch (error) {
         logger.error('Failed to parse message body:', error);
+        emitError('sqs', `Failed to parse message body: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {