@teamvibe/poller 0.1.0

package/dist/session-store.js

@@ -0,0 +1,221 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, GetCommand, PutCommand, UpdateCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'crypto';
+import { config } from './config.js';
+import { logger } from './logger.js';
+import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+function createDocClient() {
+    if (isTokenMode()) {
+        const creds = getCredentials();
+        const authConfig = getAuthConfig();
+        const client = new DynamoDBClient({
+            region: authConfig.region,
+            credentials: {
+                accessKeyId: creds.accessKeyId,
+                secretAccessKey: creds.secretAccessKey,
+                sessionToken: creds.sessionToken,
+            },
+        });
+        return DynamoDBDocumentClient.from(client);
+    }
+    return DynamoDBDocumentClient.from(new DynamoDBClient({ region: config.AWS_REGION }));
+}
+function getTableName() {
+    if (isTokenMode()) {
+        return getAuthConfig().sessionsTable;
+    }
+    return config.SESSIONS_TABLE;
+}
+const TTL_DAYS = 7;
+function buildKey(threadId) {
+    return {
+        PK: `thread#${threadId}`,
+        SK: 'SESSION',
+    };
+}
+function calculateTTL() {
+    return Math.floor(Date.now() / 1000) + TTL_DAYS * 24 * 60 * 60;
+}
+function generateLockToken() {
+    return randomUUID();
+}
+export async function getSession(threadId) {
+    const key = buildKey(threadId);
+    const result = await createDocClient().send(new GetCommand({
+        TableName: getTableName(),
+        Key: key,
+    }));
+    return result.Item || null;
+}
+export async function createSession(threadId, workspacePath) {
+    const key = buildKey(threadId);
+    const now = Date.now();
+    const lockToken = generateLockToken();
+    const session = {
+        ...key,
+        session_id: randomUUID(),
+        workspace_path: workspacePath,
+        status: 'processing',
+        lock_token: lockToken,
+        created_at: now,
+        last_activity: now,
+        message_count: 1,
+        ttl: calculateTTL(),
+    };
+    await createDocClient().send(new PutCommand({
+        TableName: getTableName(),
+        Item: session,
+        ConditionExpression: 'attribute_not_exists(PK)',
+    }));
+    logger.info(`Created new session for thread ${threadId}`);
+    return session;
+}
+export async function acquireSessionLock(threadId, workspacePath) {
+    const existingSession = await getSession(threadId);
+    // No existing session - create new one
+    if (!existingSession) {
+        try {
+            const session = await createSession(threadId, workspacePath);
+            return { success: true, session, lockToken: session.lock_token };
+        }
+        catch (error) {
+            if (error.name === 'ConditionalCheckFailedException') {
+                const session = await getSession(threadId);
+                if (session) {
+                    return { success: false, session, lockToken: null };
+                }
+            }
+            throw error;
+        }
+    }
+    // Session is processing - check for stale lock
+    if (existingSession.status === 'processing') {
+        const lockAge = Date.now() - existingSession.last_activity;
+        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...`);
+            const released = await forceReleaseStalelock(threadId, staleLockTimeout);
+            if (released) {
+                logger.info(`Stale lock released for ${threadId}, retrying acquisition`);
+                return acquireSessionLock(threadId, workspacePath);
+            }
+        }
+        logger.debug(`Session ${threadId} is already processing (age: ${Math.round(lockAge / 1000)}s)`);
+        return { success: false, session: existingSession, lockToken: null };
+    }
+    // Session is idle/waiting - try to acquire lock
+    const newLockToken = generateLockToken();
+    const now = Date.now();
+    try {
+        await createDocClient().send(new UpdateCommand({
+            TableName: getTableName(),
+            Key: buildKey(threadId),
+            UpdateExpression: 'SET #status = :processing, lock_token = :newToken, last_activity = :now, message_count = message_count + :one, #ttl = :ttl',
+            ConditionExpression: '#status IN (:idle, :waiting) AND (lock_token = :oldToken OR attribute_not_exists(lock_token))',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+                '#ttl': 'ttl',
+            },
+            ExpressionAttributeValues: {
+                ':processing': 'processing',
+                ':idle': 'idle',
+                ':waiting': 'waiting_for_input',
+                ':newToken': newLockToken,
+                ':oldToken': existingSession.lock_token,
+                ':now': now,
+                ':one': 1,
+                ':ttl': calculateTTL(),
+            },
+        }));
+        const updatedSession = {
+            ...existingSession,
+            status: 'processing',
+            lock_token: newLockToken,
+            last_activity: now,
+            message_count: existingSession.message_count + 1,
+            ttl: calculateTTL(),
+        };
+        logger.info(`Acquired lock on session ${threadId}`);
+        return { success: true, session: updatedSession, lockToken: newLockToken };
+    }
+    catch (error) {
+        if (error.name === 'ConditionalCheckFailedException') {
+            const session = await getSession(threadId);
+            logger.debug(`Failed to acquire lock on session ${threadId} - already locked`);
+            return { success: false, session: session || existingSession, lockToken: null };
+        }
+        throw error;
+    }
+}
+export async function releaseSessionLock(threadId, lockToken, newStatus = 'idle', lastMessageTs) {
+    const now = Date.now();
+    const updateExpression = lastMessageTs
+        ? 'SET #status = :newStatus, lock_token = :null, last_activity = :now, #ttl = :ttl, last_message_ts = :lastMessageTs'
+        : 'SET #status = :newStatus, lock_token = :null, last_activity = :now, #ttl = :ttl';
+    const expressionAttributeValues = {
+        ':newStatus': newStatus,
+        ':null': null,
+        ':now': now,
+        ':lockToken': lockToken,
+        ':ttl': calculateTTL(),
+    };
+    if (lastMessageTs) {
+        expressionAttributeValues[':lastMessageTs'] = lastMessageTs;
+    }
+    try {
+        await createDocClient().send(new UpdateCommand({
+            TableName: getTableName(),
+            Key: buildKey(threadId),
+            UpdateExpression: updateExpression,
+            ConditionExpression: 'lock_token = :lockToken',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+                '#ttl': 'ttl',
+            },
+            ExpressionAttributeValues: expressionAttributeValues,
+        }));
+        logger.info(`Released lock on session ${threadId}, status: ${newStatus}`);
+    }
+    catch (error) {
+        if (error.name === 'ConditionalCheckFailedException') {
+            logger.warn(`Lock token mismatch when releasing session ${threadId}`);
+            return;
+        }
+        throw error;
+    }
+}
+export async function forceReleaseStalelock(threadId, maxAgeMs) {
+    const session = await getSession(threadId);
+    if (!session || session.status !== 'processing') {
+        return false;
+    }
+    const lockAge = Date.now() - session.last_activity;
+    if (lockAge < maxAgeMs) {
+        return false;
+    }
+    try {
+        await createDocClient().send(new UpdateCommand({
+            TableName: getTableName(),
+            Key: buildKey(threadId),
+            UpdateExpression: 'SET #status = :idle, lock_token = :null',
+            ConditionExpression: '#status = :processing AND last_activity = :lastActivity',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':idle': 'idle',
+                ':null': null,
+                ':processing': 'processing',
+                ':lastActivity': session.last_activity,
+            },
+        }));
+        logger.warn(`Force released stale lock on session ${threadId} (age: ${lockAge}ms)`);
+        return true;
+    }
+    catch (error) {
+        if (error.name === 'ConditionalCheckFailedException') {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/slack-client.d.ts

@@ -0,0 +1,11 @@
+import type { TeamVibeQueueMessage } from './types.js';
+export declare function getUserInfo(botToken: string, userId: string): Promise<{
+    name: string;
+    realName: string;
+}>;
+export declare function sendSlackMessage(msg: TeamVibeQueueMessage, text: string): Promise<void>;
+export declare function sendSlackError(msg: TeamVibeQueueMessage, error: string): Promise<void>;
+export declare function addReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
+export declare function setThreadStatus(msg: TeamVibeQueueMessage, status: string): Promise<void>;
+export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): () => void;
+export declare function removeReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;

package/dist/slack-client.js

@@ -0,0 +1,139 @@
+import { WebClient } from '@slack/web-api';
+import { logger } from './logger.js';
+// Cache user info to avoid repeated API calls
+const userCache = new Map();
+// Per-token Slack client cache
+const slackClients = new Map();
+function getSlackClient(botToken) {
+    let client = slackClients.get(botToken);
+    if (!client) {
+        client = new WebClient(botToken);
+        slackClients.set(botToken, client);
+    }
+    return client;
+}
+export async function getUserInfo(botToken, userId) {
+    const cached = userCache.get(userId);
+    if (cached)
+        return cached;
+    try {
+        const slack = getSlackClient(botToken);
+        const result = await slack.users.info({ user: userId });
+        if (result.user) {
+            const info = {
+                name: result.user.name || userId,
+                realName: result.user.real_name || result.user.name || userId,
+            };
+            userCache.set(userId, info);
+            return info;
+        }
+    }
+    catch (error) {
+        if (error?.data?.error === 'missing_scope') {
+            logger.debug('Missing users:read scope - using user ID as name');
+        }
+        else {
+            logger.warn(`Failed to fetch user info for ${userId}:`, error?.data?.error || error);
+        }
+    }
+    const fallback = { name: userId, realName: userId };
+    userCache.set(userId, fallback);
+    return fallback;
+}
+export async function sendSlackMessage(msg, text) {
+    if (!msg.response_context.slack) {
+        logger.error('No Slack context in message, cannot respond');
+        return;
+    }
+    const { channel, thread_ts } = msg.response_context.slack;
+    const slack = getSlackClient(msg.teamvibe.botToken);
+    await slack.chat.postMessage({
+        channel,
+        thread_ts,
+        text,
+        unfurl_links: false,
+        unfurl_media: false,
+    });
+}
+export async function sendSlackError(msg, error) {
+    if (!msg.response_context.slack)
+        return;
+    const { channel, thread_ts } = msg.response_context.slack;
+    const slack = getSlackClient(msg.teamvibe.botToken);
+    await slack.chat.postMessage({
+        channel,
+        thread_ts,
+        text: `Error processing your request:\n\`\`\`\n${error}\n\`\`\``,
+    });
+}
+export async function addReaction(msg, emoji) {
+    if (!msg.response_context.slack)
+        return;
+    const { channel, message_ts } = msg.response_context.slack;
+    const slack = getSlackClient(msg.teamvibe.botToken);
+    try {
+        await slack.reactions.add({
+            channel,
+            timestamp: message_ts,
+            name: emoji,
+        });
+    }
+    catch (error) {
+        logger.warn(`Failed to add reaction ${emoji}:`, error);
+    }
+}
+export async function setThreadStatus(msg, status) {
+    if (!msg.response_context.slack)
+        return;
+    const { channel, thread_ts } = msg.response_context.slack;
+    const slack = getSlackClient(msg.teamvibe.botToken);
+    try {
+        await slack.apiCall('assistant.threads.setStatus', {
+            channel_id: channel,
+            thread_ts,
+            status,
+        });
+    }
+    catch (error) {
+        logger.warn(`Failed to set thread status: ${error}`);
+    }
+}
+export function startTypingIndicator(msg, statusText = 'is thinking...') {
+    // Set initial status
+    setThreadStatus(msg, statusText);
+    // Keepalive every 3 seconds (Slack clears after ~2 min timeout)
+    let failures = 0;
+    const interval = setInterval(async () => {
+        try {
+            await setThreadStatus(msg, statusText);
+            failures = 0;
+        }
+        catch {
+            failures++;
+            if (failures >= 2) {
+                clearInterval(interval);
+            }
+        }
+    }, 3000);
+    // Return cleanup function
+    return () => {
+        clearInterval(interval);
+        setThreadStatus(msg, '');
+    };
+}
+export async function removeReaction(msg, emoji) {
+    if (!msg.response_context.slack)
+        return;
+    const { channel, message_ts } = msg.response_context.slack;
+    const slack = getSlackClient(msg.teamvibe.botToken);
+    try {
+        await slack.reactions.remove({
+            channel,
+            timestamp: message_ts,
+            name: emoji,
+        });
+    }
+    catch {
+        // Ignore errors
+    }
+}

package/dist/sqs-poller.d.ts

@@ -0,0 +1,10 @@
+import type { TeamVibeQueueMessage } from './types.js';
+export interface ReceivedMessage {
+    queueMessage: TeamVibeQueueMessage;
+    receiptHandle: string;
+    messageId: string;
+}
+export declare function pollMessages(maxMessages?: number): Promise<ReceivedMessage[]>;
+export declare function deleteMessage(receiptHandle: string): Promise<void>;
+export declare function extendVisibility(receiptHandle: string, timeoutSeconds: number): Promise<void>;
+export declare function sendMessage(queueMessage: TeamVibeQueueMessage, messageGroupId: string, deduplicationId: string): Promise<void>;

package/dist/sqs-poller.js

@@ -0,0 +1,86 @@
+import { SQSClient, ReceiveMessageCommand, DeleteMessageCommand, ChangeMessageVisibilityCommand, SendMessageCommand, } from '@aws-sdk/client-sqs';
+import { config } from './config.js';
+import { logger } from './logger.js';
+import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+function createSqsClient() {
+    if (isTokenMode()) {
+        const creds = getCredentials();
+        const authConfig = getAuthConfig();
+        return new SQSClient({
+            region: authConfig.region,
+            credentials: {
+                accessKeyId: creds.accessKeyId,
+                secretAccessKey: creds.secretAccessKey,
+                sessionToken: creds.sessionToken,
+            },
+        });
+    }
+    return new SQSClient({ region: config.AWS_REGION });
+}
+function getQueueUrl() {
+    if (isTokenMode()) {
+        return getAuthConfig().sqsQueueUrl;
+    }
+    return config.SQS_QUEUE_URL;
+}
+export async function pollMessages(maxMessages = 10) {
+    logger.debug(`Polling SQS (max: ${maxMessages}, wait: ${config.POLL_WAIT_TIME_SECONDS}s)...`);
+    try {
+        const response = await createSqsClient().send(new ReceiveMessageCommand({
+            QueueUrl: getQueueUrl(),
+            MaxNumberOfMessages: Math.min(maxMessages, 10),
+            WaitTimeSeconds: config.POLL_WAIT_TIME_SECONDS,
+            VisibilityTimeout: config.VISIBILITY_TIMEOUT_SECONDS,
+            MessageAttributeNames: ['All'],
+        }));
+        if (!response.Messages || response.Messages.length === 0) {
+            logger.debug('No messages received from SQS');
+            return [];
+        }
+        logger.info(`Received ${response.Messages.length} raw message(s) from SQS`);
+        return response.Messages.map((msg) => parseMessage(msg)).filter((m) => m !== null);
+    }
+    catch (error) {
+        logger.error('Error polling SQS:', error);
+        throw error;
+    }
+}
+function parseMessage(msg) {
+    if (!msg.Body || !msg.ReceiptHandle || !msg.MessageId) {
+        logger.error('Invalid SQS message - missing required fields');
+        return null;
+    }
+    try {
+        const queueMessage = JSON.parse(msg.Body);
+        return {
+            queueMessage,
+            receiptHandle: msg.ReceiptHandle,
+            messageId: msg.MessageId,
+        };
+    }
+    catch (error) {
+        logger.error('Failed to parse message body:', error);
+        return null;
+    }
+}
+export async function deleteMessage(receiptHandle) {
+    await createSqsClient().send(new DeleteMessageCommand({
+        QueueUrl: getQueueUrl(),
+        ReceiptHandle: receiptHandle,
+    }));
+}
+export async function extendVisibility(receiptHandle, timeoutSeconds) {
+    await createSqsClient().send(new ChangeMessageVisibilityCommand({
+        QueueUrl: getQueueUrl(),
+        ReceiptHandle: receiptHandle,
+        VisibilityTimeout: timeoutSeconds,
+    }));
+}
+export async function sendMessage(queueMessage, messageGroupId, deduplicationId) {
+    await createSqsClient().send(new SendMessageCommand({
+        QueueUrl: getQueueUrl(),
+        MessageBody: JSON.stringify(queueMessage),
+        MessageGroupId: messageGroupId,
+        MessageDeduplicationId: deduplicationId,
+    }));
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export interface TeamVibeQueueMessage {
+    id: string;
+    source: 'slack' | 'cron';
+    thread_id: string;
+    sender: {
+        id: string;
+        name: string;
+    };
+    text: string;
+    attachments: Array<{
+        url: string;
+        filename: string;
+        mimetype: string;
+    }>;
+    response_context: {
+        slack?: {
+            channel: string;
+            thread_ts: string;
+            message_ts: string;
+        };
+    };
+    type: 'message' | 'approval_response' | 'button_click';
+    approval?: {
+        action_id: string;
+        approved: boolean;
+    };
+    teamvibe: {
+        workspaceId: string;
+        botId: string;
+        botToken: string;
+        channelId: string;
+        persona: {
+            personaId: string;
+            name: string;
+            systemPrompt?: string;
+            knowledgeBase?: {
+                kbId: string;
+                gitRepoUrl: string;
+                branch: string;
+                claudePath: string;
+            };
+        };
+    };
+}
+export interface SessionRecord {
+    PK: string;
+    SK: string;
+    session_id: string;
+    workspace_path: string;
+    status: SessionStatus;
+    lock_token: string;
+    created_at: number;
+    last_activity: number;
+    message_count: number;
+    last_message_ts?: string;
+    ttl: number;
+}
+export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input';

package/dist/types.js

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

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@teamvibe/poller",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "teamvibe-poller": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.470.0",
+    "@aws-sdk/client-sqs": "^3.470.0",
+    "@aws-sdk/lib-dynamodb": "^3.470.0",
+    "@slack/web-api": "^7.0.0",
+    "dotenv": "^17.2.3",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}