@teamvibe/poller 0.1.0

package/dist/index.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import { config } from './config.js';
+import { logger } from './logger.js';
+import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
+import { spawnClaudeCode, isAtCapacity, getActiveProcessCount } from './claude-spawner.js';
+import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
+import { acquireSessionLock, releaseSessionLock } from './session-store.js';
+import { getKnowledgeBasePath, ensureDirectories } from './kb-manager.js';
+import { initAuth, stopRefresh } from './auth-provider.js';
+logger.info('TeamVibe Poller starting...');
+logger.info(`   Max concurrent: ${config.MAX_CONCURRENT_SESSIONS}`);
+logger.info(`   KB base path: ${config.KB_BASE_PATH}`);
+// Track active message processing
+const processingMessages = new Set();
+// Per-thread completion signals
+const threadCompletionSignals = new Map();
+const waitingCountByThread = new Map();
+function getQueueStats() {
+    let totalWaiting = 0;
+    waitingCountByThread.forEach((count) => {
+        totalWaiting += count;
+    });
+    return {
+        processing: processingMessages.size,
+        threadsWithWaiting: waitingCountByThread.size,
+        totalWaiting,
+    };
+}
+function logQueueState(context) {
+    const stats = getQueueStats();
+    logger.info(`[Queue] ${context} | Processing: ${stats.processing}, Threads with waiting: ${stats.threadsWithWaiting}, Total waiting: ${stats.totalWaiting}`);
+}
+function waitForThreadCompletion(threadId) {
+    return new Promise((resolve) => {
+        const signals = threadCompletionSignals.get(threadId) || [];
+        signals.push(resolve);
+        threadCompletionSignals.set(threadId, signals);
+        const currentCount = waitingCountByThread.get(threadId) || 0;
+        waitingCountByThread.set(threadId, currentCount + 1);
+        logger.info(`[Queue] Thread ${threadId}: ${currentCount + 1} message(s) now waiting`);
+        logQueueState('After enqueue');
+    });
+}
+function signalThreadCompletion(threadId) {
+    const signals = threadCompletionSignals.get(threadId);
+    const waitingCount = signals?.length || 0;
+    if (signals && signals.length > 0) {
+        logger.info(`[Queue] Thread ${threadId} completed, waking ${waitingCount} waiting message(s)`);
+        signals.forEach((resolve) => resolve());
+        threadCompletionSignals.delete(threadId);
+        waitingCountByThread.delete(threadId);
+        logQueueState('After signal');
+    }
+}
+function startHeartbeat(receiptHandle, sessionLog) {
+    return setInterval(async () => {
+        try {
+            await extendVisibility(receiptHandle, config.VISIBILITY_TIMEOUT_SECONDS);
+            sessionLog.info(`Heartbeat: extended visibility by ${config.VISIBILITY_TIMEOUT_SECONDS}s`);
+        }
+        catch (error) {
+            sessionLog.error(`Heartbeat failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }, config.HEARTBEAT_INTERVAL_MS);
+}
+async function processMessage(received) {
+    const { queueMessage, receiptHandle, messageId } = received;
+    const logSessionId = messageId.slice(0, 8);
+    const threadId = queueMessage.thread_id;
+    const sessionLog = logger.createSession(logSessionId);
+    // Fetch user info if we only have ID
+    if (queueMessage.source !== 'cron' &&
+        queueMessage.sender.name === 'Unknown User' &&
+        queueMessage.sender.id !== 'unknown') {
+        const userInfo = await getUserInfo(queueMessage.teamvibe.botToken, queueMessage.sender.id);
+        queueMessage.sender.name = userInfo.realName;
+        sessionLog.info(`Resolved user: ${userInfo.realName} (@${userInfo.name})`);
+    }
+    sessionLog.info(`Processing message from ${queueMessage.sender.name} (${queueMessage.sender.id})`);
+    sessionLog.info(`Thread: ${threadId}`);
+    sessionLog.info(`Persona: ${queueMessage.teamvibe.persona?.name ?? 'none'}`);
+    sessionLog.info(`Type: ${queueMessage.type}`);
+    sessionLog.info(`Log file: ${sessionLog.getLogFile()}`);
+    // Get knowledge base path for this persona
+    const kbPath = await getKnowledgeBasePath(queueMessage.teamvibe.persona?.knowledgeBase);
+    // Try to acquire session lock
+    let lockResult = await acquireSessionLock(threadId, kbPath);
+    if (!lockResult.success) {
+        sessionLog.info(`Session ${threadId} is processing, waiting for completion...`);
+        const waitHeartbeat = startHeartbeat(receiptHandle, sessionLog);
+        try {
+            await waitForThreadCompletion(threadId);
+            sessionLog.info(`Thread ${threadId} completed, retrying lock acquisition`);
+            lockResult = await acquireSessionLock(threadId, kbPath);
+            if (!lockResult.success) {
+                sessionLog.info('Lock still held, re-queuing for next completion');
+                clearInterval(waitHeartbeat);
+                return processMessage(received);
+            }
+        }
+        finally {
+            clearInterval(waitHeartbeat);
+        }
+    }
+    const { session, lockToken } = lockResult;
+    const isFirstMessage = session.message_count === 1;
+    sessionLog.info(`Acquired lock on session ${threadId}, Claude session: ${session.session_id}, mode: ${isFirstMessage ? 'new' : 'resume'}, message #${session.message_count}`);
+    logQueueState(`Lock acquired for ${threadId}`);
+    processingMessages.add(messageId);
+    const heartbeat = startHeartbeat(receiptHandle, sessionLog);
+    const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
+        queueMessage.response_context.slack?.message_ts);
+    // Start typing indicator
+    const stopTyping = hasSlackContext
+        ? startTypingIndicator(queueMessage)
+        : undefined;
+    try {
+        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts);
+        stopTyping?.();
+        if (result.success) {
+            sessionLog.info('Claude Code completed successfully');
+            if (lockToken) {
+                const lastMessageTs = queueMessage.response_context.slack?.message_ts;
+                await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
+            }
+        }
+        else {
+            sessionLog.error(`Claude Code failed: ${result.error}`);
+            if (hasSlackContext) {
+                await sendSlackError(queueMessage, result.error || `Process exited with code ${result.exitCode}`);
+                await addReaction(queueMessage, 'x');
+            }
+            if (lockToken) {
+                await releaseSessionLock(threadId, lockToken, 'idle');
+            }
+        }
+        await deleteMessage(receiptHandle);
+        sessionLog.info('Message processed and deleted');
+    }
+    catch (error) {
+        stopTyping?.();
+        sessionLog.error(`Error processing message: ${error instanceof Error ? error.message : error}`);
+        if (lockToken) {
+            try {
+                await releaseSessionLock(threadId, lockToken, 'idle');
+            }
+            catch (releaseError) {
+                sessionLog.error(`Failed to release lock: ${releaseError}`);
+            }
+        }
+        if (hasSlackContext) {
+            try {
+                await sendSlackError(queueMessage, error instanceof Error ? error.message : 'Unknown error');
+                await addReaction(queueMessage, 'x');
+            }
+            catch (slackError) {
+                sessionLog.error(`Failed to send Slack error: ${slackError}`);
+            }
+        }
+        throw error;
+    }
+    finally {
+        clearInterval(heartbeat);
+        processingMessages.delete(messageId);
+        signalThreadCompletion(threadId);
+    }
+}
+async function pollLoop() {
+    logger.info('Poll loop started');
+    while (true) {
+        try {
+            if (isAtCapacity()) {
+                logger.debug(`At capacity (${getActiveProcessCount()}/${config.MAX_CONCURRENT_SESSIONS}), waiting...`);
+                await sleep(1000);
+                continue;
+            }
+            const availableSlots = config.MAX_CONCURRENT_SESSIONS - getActiveProcessCount();
+            logger.debug(`Polling for up to ${availableSlots} messages...`);
+            const messages = await pollMessages(availableSlots);
+            if (messages.length === 0) {
+                continue;
+            }
+            logger.info(`Received ${messages.length} message(s) from SQS`);
+            logQueueState('After SQS poll');
+            const processPromises = messages.map((msg) => processMessage(msg).catch((error) => {
+                logger.error(`Failed to process message ${msg.messageId}:`, error);
+            }));
+            // Don't await - let them run in parallel
+            Promise.all(processPromises);
+        }
+        catch (error) {
+            logger.error('Error in poll loop:', error);
+            await sleep(5000);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Graceful shutdown
+let shuttingDown = false;
+async function shutdown(signal) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    logger.info(`${signal} received, shutting down gracefully...`);
+    stopRefresh();
+    const shutdownTimeout = 30000;
+    const startTime = Date.now();
+    while (processingMessages.size > 0) {
+        if (Date.now() - startTime > shutdownTimeout) {
+            logger.warn('Shutdown timeout reached, forcing exit');
+            break;
+        }
+        logger.info(`Waiting for ${processingMessages.size} message(s) to complete...`);
+        await sleep(1000);
+    }
+    logger.info('Shutdown complete');
+    process.exit(0);
+}
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+async function main() {
+    // Token-based auth: fetch credentials before starting
+    if (config.TEAMVIBE_API_URL && config.TEAMVIBE_POLLER_TOKEN) {
+        await initAuth(config.TEAMVIBE_API_URL, config.TEAMVIBE_POLLER_TOKEN);
+    }
+    else {
+        logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
+        logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
+    }
+    await ensureDirectories();
+    await pollLoop();
+}
+main().catch((error) => {
+    logger.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/kb-manager.d.ts

@@ -0,0 +1,15 @@
+interface KBConfig {
+    kbId: string;
+    gitRepoUrl: string;
+    branch: string;
+    claudePath: string;
+}
+/**
+ * Get or clone KB for a persona. Returns the working directory path.
+ */
+export declare function getKnowledgeBasePath(kb?: KBConfig): Promise<string>;
+/**
+ * Ensure base paths exist
+ */
+export declare function ensureDirectories(): Promise<void>;
+export {};

package/dist/kb-manager.js

@@ -0,0 +1,61 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { config } from './config.js';
+import { logger } from './logger.js';
+const execAsync = promisify(exec);
+// Cooldown tracker per KB
+const lastUpdateTimes = new Map();
+/**
+ * Get or clone KB for a persona. Returns the working directory path.
+ */
+export async function getKnowledgeBasePath(kb) {
+    if (!kb?.gitRepoUrl)
+        return config.DEFAULT_KB_PATH;
+    const kbDir = join(config.KB_BASE_PATH, kb.kbId);
+    if (!existsSync(kbDir)) {
+        logger.info(`Cloning KB ${kb.kbId} from ${kb.gitRepoUrl} (branch: ${kb.branch})...`);
+        await execAsync(`git clone --branch ${kb.branch} ${kb.gitRepoUrl} ${kbDir}`);
+        logger.info(`KB ${kb.kbId} cloned successfully`);
+    }
+    else if (config.KB_AUTO_UPDATE) {
+        await updateKB(kbDir, kb.kbId, kb.branch);
+    }
+    return kbDir;
+}
+/**
+ * Update a KB repo (respects cooldown)
+ */
+async function updateKB(kbDir, kbId, branch) {
+    const now = Date.now();
+    const lastUpdate = lastUpdateTimes.get(kbId) || 0;
+    if (now - lastUpdate < config.KB_UPDATE_COOLDOWN_MS) {
+        logger.debug(`KB ${kbId} update skipped - cooldown active (${Math.round((config.KB_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
+        return;
+    }
+    try {
+        logger.info(`Updating KB ${kbId} at ${kbDir}...`);
+        await execAsync(`git fetch origin ${branch} && git reset --hard origin/${branch}`, {
+            cwd: kbDir,
+        });
+        lastUpdateTimes.set(kbId, Date.now());
+        logger.info(`KB ${kbId} updated successfully`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to update KB ${kbId}: ${errorMessage}`);
+    }
+}
+/**
+ * Ensure base paths exist
+ */
+export async function ensureDirectories() {
+    const { mkdirSync } = await import('fs');
+    if (!existsSync(config.KB_BASE_PATH)) {
+        mkdirSync(config.KB_BASE_PATH, { recursive: true });
+    }
+    if (!existsSync(config.DEFAULT_KB_PATH)) {
+        mkdirSync(config.DEFAULT_KB_PATH, { recursive: true });
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,18 @@
+export declare class SessionLogger {
+    private sessionId;
+    private logFile;
+    constructor(sessionId: string);
+    private write;
+    info(message: string): void;
+    error(message: string): void;
+    claude(stream: 'stdout' | 'stderr', message: string): void;
+    logPrompt(prompt: string): void;
+    getLogFile(): string;
+}
+export declare const logger: {
+    info(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    createSession(sessionId: string): SessionLogger;
+};

package/dist/logger.js

@@ -0,0 +1,97 @@
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LOG_DIR = join(__dirname, '../.local/logs');
+const SESSIONS_DIR = join(LOG_DIR, 'sessions');
+const LOG_FILE = join(LOG_DIR, 'poller.log');
+if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+}
+if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function formatDate(date) {
+    return date.toISOString();
+}
+function writeToFile(level, message, ...args) {
+    const timestamp = formatDate(new Date());
+    const formattedArgs = args
+        .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
+        .join(' ');
+    const logLine = `[${timestamp}] [${level}] ${message} ${formattedArgs}\n`;
+    try {
+        appendFileSync(LOG_FILE, logLine);
+    }
+    catch {
+        // Fallback to console if file write fails
+    }
+}
+export class SessionLogger {
+    sessionId;
+    logFile;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        this.logFile = join(SESSIONS_DIR, `${timestamp}_${sessionId}.log`);
+    }
+    write(level, message) {
+        const timestamp = formatDate(new Date());
+        const logLine = `[${timestamp}] [${level}] ${message}\n`;
+        try {
+            appendFileSync(this.logFile, logLine);
+        }
+        catch {
+            // Silent fallback
+        }
+    }
+    info(message) {
+        console.log(`[${this.sessionId}] ${message}`);
+        this.write('INFO', message);
+        writeToFile('INFO', `[${this.sessionId}] ${message}`);
+    }
+    error(message) {
+        console.error(`[${this.sessionId}] ${message}`);
+        this.write('ERROR', message);
+        writeToFile('ERROR', `[${this.sessionId}] ${message}`);
+    }
+    claude(stream, message) {
+        const prefix = `[Claude ${stream}]`;
+        if (stream === 'stderr') {
+            console.error(`[${this.sessionId}] ${prefix}`, message);
+        }
+        else {
+            console.log(`[${this.sessionId}] ${prefix}`, message);
+        }
+        this.write(`CLAUDE_${stream.toUpperCase()}`, message);
+    }
+    logPrompt(prompt) {
+        this.write('PROMPT', `\n${'='.repeat(50)}\n${prompt}\n${'='.repeat(50)}`);
+    }
+    getLogFile() {
+        return this.logFile;
+    }
+}
+export const logger = {
+    info(message, ...args) {
+        console.log(message, ...args);
+        writeToFile('INFO', message, ...args);
+    },
+    error(message, ...args) {
+        console.error(message, ...args);
+        writeToFile('ERROR', message, ...args);
+    },
+    warn(message, ...args) {
+        console.warn(message, ...args);
+        writeToFile('WARN', message, ...args);
+    },
+    debug(message, ...args) {
+        if (process.env['DEBUG']) {
+            console.debug(message, ...args);
+        }
+        writeToFile('DEBUG', message, ...args);
+    },
+    createSession(sessionId) {
+        return new SessionLogger(sessionId);
+    },
+};

package/dist/scripts/slack-tool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/slack-tool.js

@@ -0,0 +1,132 @@
+import { WebClient } from '@slack/web-api';
+const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
+const CHANNEL = process.env['SLACK_CHANNEL'];
+const THREAD_TS = process.env['SLACK_THREAD_TS'];
+const MESSAGE_TS = process.env['SLACK_MESSAGE_TS'];
+function fail(error) {
+    console.log(JSON.stringify({ ok: false, error }));
+    process.exit(1);
+}
+function succeed(data = {}) {
+    console.log(JSON.stringify({ ok: true, ...data }));
+    process.exit(0);
+}
+if (!BOT_TOKEN)
+    fail('SLACK_BOT_TOKEN not set');
+const slack = new WebClient(BOT_TOKEN);
+const [, , command, ...args] = process.argv;
+async function main() {
+    switch (command) {
+        case 'send_message': {
+            const text = args.join(' ');
+            if (!text)
+                fail('Message text required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            console.error(`[slack-tool] send_message: channel=${CHANNEL}, thread_ts=${THREAD_TS}`);
+            const result = await slack.chat.postMessage({
+                channel: CHANNEL,
+                thread_ts: THREAD_TS,
+                text,
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+            console.error(`[slack-tool] posted: ts=${result.ts}, thread_ts=${result.message?.thread_ts}`);
+            succeed({ ts: result.ts });
+            break;
+        }
+        case 'add_reaction': {
+            const emoji = args[0];
+            if (!emoji)
+                fail('Emoji name required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!MESSAGE_TS)
+                fail('SLACK_MESSAGE_TS not set');
+            await slack.reactions.add({
+                channel: CHANNEL,
+                timestamp: MESSAGE_TS,
+                name: emoji,
+            });
+            succeed();
+            break;
+        }
+        case 'remove_reaction': {
+            const emoji = args[0];
+            if (!emoji)
+                fail('Emoji name required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!MESSAGE_TS)
+                fail('SLACK_MESSAGE_TS not set');
+            await slack.reactions.remove({
+                channel: CHANNEL,
+                timestamp: MESSAGE_TS,
+                name: emoji,
+            });
+            succeed();
+            break;
+        }
+        case 'read_thread': {
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            const limit = parseInt(args[0] || '20', 10);
+            const result = await slack.conversations.replies({
+                channel: CHANNEL,
+                ts: THREAD_TS,
+                limit,
+            });
+            const messages = (result.messages || []).map((m) => ({
+                user: m.user || m.bot_id || 'unknown',
+                text: m.text || '',
+                ts: m.ts,
+                is_bot: Boolean(m.bot_id),
+            }));
+            succeed({ messages });
+            break;
+        }
+        case 'set_status': {
+            const status = args.join(' ');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            await slack.apiCall('assistant.threads.setStatus', {
+                channel_id: CHANNEL,
+                thread_ts: THREAD_TS,
+                status,
+            });
+            succeed();
+            break;
+        }
+        case 'upload_snippet': {
+            const title = args[0];
+            const content = args[1];
+            const filetype = args[2] || 'text';
+            if (!title || !content)
+                fail('Title and content required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            await slack.filesUploadV2({
+                channel_id: CHANNEL,
+                thread_ts: THREAD_TS,
+                title,
+                content,
+                filetype,
+            });
+            succeed();
+            break;
+        }
+        default:
+            fail(`Unknown command: ${command}. Available: send_message, add_reaction, remove_reaction, read_thread, set_status, upload_snippet`);
+    }
+}
+main().catch((err) => {
+    fail(err instanceof Error ? err.message : String(err));
+});

package/dist/session-store.d.ts

@@ -0,0 +1,11 @@
+import type { SessionRecord, SessionStatus } from './types.js';
+export declare function getSession(threadId: string): Promise<SessionRecord | null>;
+export declare function createSession(threadId: string, workspacePath: string): Promise<SessionRecord>;
+export interface AcquireLockResult {
+    success: boolean;
+    session: SessionRecord;
+    lockToken: string | null;
+}
+export declare function acquireSessionLock(threadId: string, workspacePath: string): Promise<AcquireLockResult>;
+export declare function releaseSessionLock(threadId: string, lockToken: string, newStatus?: SessionStatus, lastMessageTs?: string): Promise<void>;
+export declare function forceReleaseStalelock(threadId: string, maxAgeMs: number): Promise<boolean>;