@teamvibe/poller 0.1.0

package/dist/auth-provider.d.ts

@@ -0,0 +1,17 @@
+interface AuthCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    expiration: string;
+}
+interface AuthConfig {
+    sqsQueueUrl: string;
+    sessionsTable: string;
+    region: string;
+}
+export declare function initAuth(apiUrl: string, token: string): Promise<void>;
+export declare function getCredentials(): AuthCredentials;
+export declare function getAuthConfig(): AuthConfig;
+export declare function isTokenMode(): boolean;
+export declare function stopRefresh(): void;
+export {};

package/dist/auth-provider.js

@@ -0,0 +1,62 @@
+import { logger } from './logger.js';
+let currentCredentials = null;
+let currentConfig = null;
+let refreshTimer = null;
+const REFRESH_INTERVAL_MS = 50 * 60 * 1000; // 50 minutes (before 1hr expiry)
+async function fetchCredentials(apiUrl, token) {
+    const response = await fetch(`${apiUrl}/auth`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Auth failed (${response.status}): ${body}`);
+    }
+    return response.json();
+}
+export async function initAuth(apiUrl, token) {
+    logger.info('Authenticating with TeamVibe API...');
+    const auth = await fetchCredentials(apiUrl, token);
+    currentCredentials = auth.credentials;
+    currentConfig = auth.config;
+    logger.info(`Authenticated successfully. Region: ${auth.config.region}`);
+    logger.info(`   SQS Queue: ${auth.config.sqsQueueUrl}`);
+    logger.info(`   Sessions Table: ${auth.config.sessionsTable}`);
+    // Schedule credential refresh
+    refreshTimer = setInterval(async () => {
+        try {
+            logger.info('Refreshing credentials...');
+            const refreshed = await fetchCredentials(apiUrl, token);
+            currentCredentials = refreshed.credentials;
+            currentConfig = refreshed.config;
+            logger.info('Credentials refreshed successfully');
+        }
+        catch (error) {
+            logger.error(`Credential refresh failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }, REFRESH_INTERVAL_MS);
+}
+export function getCredentials() {
+    if (!currentCredentials) {
+        throw new Error('Auth not initialized. Call initAuth() first.');
+    }
+    return currentCredentials;
+}
+export function getAuthConfig() {
+    if (!currentConfig) {
+        throw new Error('Auth not initialized. Call initAuth() first.');
+    }
+    return currentConfig;
+}
+export function isTokenMode() {
+    return currentCredentials !== null;
+}
+export function stopRefresh() {
+    if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+    }
+}

package/dist/claude-spawner.d.ts

@@ -0,0 +1,11 @@
+import type { TeamVibeQueueMessage } from './types.js';
+import { type SessionLogger } from './logger.js';
+export interface SpawnResult {
+    success: boolean;
+    output: string;
+    exitCode: number | null;
+    error?: string;
+}
+export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string): Promise<SpawnResult>;
+export declare function getActiveProcessCount(): number;
+export declare function isAtCapacity(): boolean;

package/dist/claude-spawner.js

@@ -0,0 +1,316 @@
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { WebClient } from '@slack/web-api';
+import { config } from './config.js';
+import { logger } from './logger.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SLACK_TOOL_PATH = join(__dirname, 'scripts/slack-tool.ts');
+// Per-token Slack client cache for thread context
+const slackClients = new Map();
+function getSlackClient(botToken) {
+    let client = slackClients.get(botToken);
+    if (!client) {
+        client = new WebClient(botToken);
+        slackClients.set(botToken, client);
+    }
+    return client;
+}
+async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
+    try {
+        const slack = getSlackClient(botToken);
+        const result = await slack.conversations.replies({
+            channel,
+            ts: threadTs,
+            limit: 100,
+        });
+        if (!result.messages)
+            return 0;
+        const newMessages = result.messages.filter((msg) => {
+            if (!msg.ts)
+                return false;
+            if (parseFloat(msg.ts) <= parseFloat(sinceTs))
+                return false;
+            if (msg.bot_id)
+                return false;
+            return true;
+        });
+        return newMessages.length;
+    }
+    catch (error) {
+        logger.warn(`Failed to count new thread messages: ${error}`);
+        return 0;
+    }
+}
+function buildSystemPrompt(persona) {
+    let prompt = persona?.systemPrompt || getDefaultSystemPrompt();
+    // Append standard communication instructions
+    prompt += `\n\n## Communication
+You have Slack tools available via Bash. Use these commands to communicate:
+
+**Send a message** (REQUIRED - always use this to respond):
+\`\`\`bash
+npx tsx $SLACK_TOOL_PATH send_message "Your message here"
+\`\`\`
+
+**Add emoji reaction:**
+\`\`\`bash
+npx tsx $SLACK_TOOL_PATH add_reaction emoji_name
+\`\`\`
+
+**Remove emoji reaction:**
+\`\`\`bash
+npx tsx $SLACK_TOOL_PATH remove_reaction emoji_name
+\`\`\`
+
+**Read thread history:**
+\`\`\`bash
+npx tsx $SLACK_TOOL_PATH read_thread [limit]
+\`\`\`
+
+**Upload code/text snippet:**
+\`\`\`bash
+npx tsx $SLACK_TOOL_PATH upload_snippet "title" "content" [filetype]
+\`\`\`
+
+**Important:** To respond to the user, you MUST use the send_message command via Bash - plain text output will NOT be seen by the user. Always send at least one message back.
+All commands return JSON: {"ok": true, ...} on success or {"ok": false, "error": "..."} on failure.
+
+## Response Guidelines
+1. **Always respond** - Use send_message to reply
+2. **Acknowledge long tasks** - Send a quick message first for time-consuming work
+3. **Be concise** - Use bullet points, keep it focused
+4. **Use Slack formatting** - \`code\`, *bold*, _italic_, \\\`\\\`\\\`code blocks\\\`\\\`\\\`, > quotes
+5. **For long code** - Use upload_snippet instead of huge code blocks`;
+    return prompt;
+}
+function getDefaultSystemPrompt() {
+    return `You are a helpful assistant operating in a team's Slack workspace. Team members contact you via Slack messages.
+
+## Your Setup
+You have access to the company's **knowledge base** (the current working directory). You should:
+- Read and search files to understand available tools and information
+- Execute available commands, skills, and automation scripts
+- Run shell commands for tasks (API calls, data processing, etc.)
+- Create temporary local files when needed for your work
+- Do NOT create new permanent files or edit existing files unless explicitly asked`;
+}
+function buildPrompt(msg, systemPrompt, resumeHint) {
+    let prompt = systemPrompt;
+    prompt += '\n\n---\n\n## Incoming Slack Message\n\n';
+    prompt += `**From:** ${msg.sender.name}`;
+    if (msg.sender.id && msg.sender.id !== msg.sender.name) {
+        prompt += ` (${msg.sender.id})`;
+    }
+    prompt += '\n';
+    if (msg.response_context.slack) {
+        const slack = msg.response_context.slack;
+        const channelType = slack.channel.startsWith('D')
+            ? 'Direct Message'
+            : `Channel ${slack.channel}`;
+        prompt += `**Channel:** ${channelType}\n`;
+    }
+    prompt += `\n**Message:**\n${msg.text}`;
+    if (msg.attachments.length > 0) {
+        prompt += '\n\n**Attachments:**\n';
+        msg.attachments.forEach((att) => {
+            prompt += `- ${att.filename} (${att.mimetype}): ${att.url}\n`;
+        });
+    }
+    if (msg.type === 'approval_response' && msg.approval) {
+        prompt += `\n\n**Action Response:** User ${msg.approval.approved ? 'APPROVED' : 'REJECTED'} the pending action: ${msg.approval.action_id}`;
+    }
+    if (resumeHint) {
+        prompt += `\n\n${resumeHint}`;
+    }
+    prompt += '\n\n---\n\nNow respond to this user using the send_message command via Bash.';
+    return prompt;
+}
+function truncateOutput(output, maxLen = 200) {
+    const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+    if (outputStr.includes('"type":"base64"') ||
+        outputStr.includes('base64,') ||
+        (outputStr.length > 500 && (outputStr.match(/[A-Za-z0-9+/=]/g)?.length || 0) / outputStr.length > 0.9)) {
+        return '[binary/base64 data truncated]';
+    }
+    else if (outputStr.length > maxLen) {
+        return outputStr.slice(0, maxLen) + '...';
+    }
+    return outputStr;
+}
+function formatStreamEvent(event) {
+    switch (event.type) {
+        case 'system':
+            return `[system] ${event.message || JSON.stringify(event)}`;
+        case 'user':
+            if (event.message?.content && Array.isArray(event.message.content)) {
+                const parts = event.message.content
+                    .map((c) => {
+                    if (c.type === 'tool_result') {
+                        return `[tool_result] ${truncateOutput(c.content)}`;
+                    }
+                    return null;
+                })
+                    .filter(Boolean);
+                return parts.length > 0 ? `[user] ${parts.join(' ')}` : null;
+            }
+            return null;
+        case 'assistant':
+            if (event.message?.content) {
+                const parts = event.message.content
+                    .map((c) => {
+                    if (c.type === 'text')
+                        return c.text;
+                    if (c.type === 'tool_use')
+                        return `[tool_call] ${c.name}`;
+                    return null;
+                })
+                    .filter(Boolean);
+                return parts.length > 0 ? `[assistant] ${parts.join(' ')}` : null;
+            }
+            return null;
+        case 'tool_use': {
+            const input = JSON.stringify(event.input || {});
+            const truncatedInput = input.length > 200 ? input.slice(0, 200) + '...' : input;
+            return `[tool_use] ${event.name}(${truncatedInput})`;
+        }
+        case 'tool_result':
+            return `[tool_result] ${truncateOutput(event.content || event.output || '')}`;
+        case 'result':
+            return `[result] Cost: $${event.cost_usd?.toFixed(4) || '?'}, Duration: ${event.duration_ms || '?'}ms`;
+        default:
+            return null;
+    }
+}
+export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs) {
+    const slackContext = msg.response_context.slack;
+    const isCronMessage = msg.source === 'cron';
+    if (!slackContext && !isCronMessage) {
+        throw new Error('No Slack context in message');
+    }
+    // Build resume hint
+    let resumeHint;
+    if (!isFirstMessage && lastMessageTs && slackContext?.channel && slackContext?.thread_ts) {
+        const newMessageCount = await countNewThreadMessages(msg.teamvibe.botToken, slackContext.channel, slackContext.thread_ts, lastMessageTs);
+        if (newMessageCount > 0) {
+            resumeHint = `**Resumed session:** ${newMessageCount} new message(s) in the thread since your last response. Consider using \`read_thread\` to see what was discussed before responding.`;
+        }
+        else {
+            resumeHint = `**Resumed session:** No new messages since your last response.`;
+        }
+    }
+    return new Promise((resolve) => {
+        const systemPrompt = buildSystemPrompt(msg.teamvibe.persona);
+        const prompt = buildPrompt(msg, systemPrompt, resumeHint);
+        const args = [
+            '--print',
+            '--verbose',
+            '--output-format',
+            'stream-json',
+            '--max-turns',
+            '50',
+            '--allowedTools',
+            'Bash,Read,WebFetch',
+        ];
+        // Handle session continuity
+        if (sessionId) {
+            if (isFirstMessage) {
+                args.push('--session-id', sessionId);
+            }
+            else {
+                args.push('--resume', sessionId);
+            }
+        }
+        sessionLog.info(`Spawning Claude Code with args: ${JSON.stringify(args)}`);
+        sessionLog.info(`Working directory: ${cwd}`);
+        sessionLog.info(`Prompt length: ${prompt.length} chars`);
+        sessionLog.logPrompt(prompt);
+        const proc = spawn(config.CLAUDE_CLI_PATH, args, {
+            cwd,
+            env: {
+                ...process.env,
+                CI: 'true',
+                SLACK_BOT_TOKEN: msg.teamvibe.botToken,
+                SLACK_TOOL_PATH,
+                SLACK_FILES_DIR: join(cwd, '.local/slack-files'),
+                ...(slackContext && {
+                    SLACK_CHANNEL: slackContext.channel,
+                    SLACK_THREAD_TS: slackContext.thread_ts,
+                    SLACK_MESSAGE_TS: slackContext.message_ts,
+                }),
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Track active process
+        activeProcesses.set(msg.id, proc);
+        proc.stdin?.write(prompt);
+        proc.stdin?.end();
+        let stdout = '';
+        let stderr = '';
+        let stdoutBuffer = '';
+        proc.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            stdout += chunk;
+            stdoutBuffer += chunk;
+            const lastNewline = stdoutBuffer.lastIndexOf('\n');
+            if (lastNewline === -1)
+                return;
+            const completeData = stdoutBuffer.slice(0, lastNewline);
+            stdoutBuffer = stdoutBuffer.slice(lastNewline + 1);
+            const lines = completeData.split('\n').filter((line) => line.trim());
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    const formatted = formatStreamEvent(event);
+                    if (formatted) {
+                        sessionLog.claude('stdout', formatted);
+                    }
+                }
+                catch {
+                    const truncated = line.length > 500 ? line.slice(0, 500) + '...' : line;
+                    sessionLog.claude('stdout', truncated.trimEnd());
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            stderr += chunk;
+            sessionLog.claude('stderr', chunk.trimEnd());
+        });
+        const timeout = setTimeout(() => {
+            logger.error(`Claude Code process timed out after ${config.CLAUDE_TIMEOUT_MS}ms`);
+            proc.kill('SIGTERM');
+            setTimeout(() => proc.kill('SIGKILL'), 5000);
+        }, config.CLAUDE_TIMEOUT_MS);
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            activeProcesses.delete(msg.id);
+            const result = {
+                success: code === 0,
+                output: stdout,
+                exitCode: code,
+            };
+            if (code !== 0) {
+                result.error = stderr || `Process exited with code ${code}`;
+            }
+            resolve(result);
+        });
+        proc.on('error', (error) => {
+            clearTimeout(timeout);
+            activeProcesses.delete(msg.id);
+            resolve({
+                success: false,
+                output: stdout,
+                exitCode: null,
+                error: error.message,
+            });
+        });
+    });
+}
+const activeProcesses = new Map();
+export function getActiveProcessCount() {
+    return activeProcesses.size;
+}
+export function isAtCapacity() {
+    return activeProcesses.size >= config.MAX_CONCURRENT_SESSIONS;
+}

package/dist/config.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+declare const configSchema: z.ZodObject<{
+    AWS_REGION: z.ZodDefault<z.ZodString>;
+    SQS_QUEUE_URL: z.ZodOptional<z.ZodString>;
+    SESSIONS_TABLE: z.ZodOptional<z.ZodString>;
+    TEAMVIBE_API_URL: z.ZodOptional<z.ZodString>;
+    TEAMVIBE_POLLER_TOKEN: z.ZodOptional<z.ZodString>;
+    MAX_CONCURRENT_SESSIONS: z.ZodDefault<z.ZodNumber>;
+    POLL_WAIT_TIME_SECONDS: z.ZodDefault<z.ZodNumber>;
+    VISIBILITY_TIMEOUT_SECONDS: z.ZodDefault<z.ZodNumber>;
+    HEARTBEAT_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
+    CLAUDE_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
+    STALE_LOCK_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
+    KB_BASE_PATH: z.ZodDefault<z.ZodString>;
+    DEFAULT_KB_PATH: z.ZodDefault<z.ZodString>;
+    CLAUDE_CLI_PATH: z.ZodDefault<z.ZodString>;
+    KB_AUTO_UPDATE: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
+    KB_UPDATE_COOLDOWN_MS: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    AWS_REGION: string;
+    MAX_CONCURRENT_SESSIONS: number;
+    POLL_WAIT_TIME_SECONDS: number;
+    VISIBILITY_TIMEOUT_SECONDS: number;
+    HEARTBEAT_INTERVAL_MS: number;
+    CLAUDE_TIMEOUT_MS: number;
+    STALE_LOCK_TIMEOUT_MS: number;
+    KB_BASE_PATH: string;
+    DEFAULT_KB_PATH: string;
+    CLAUDE_CLI_PATH: string;
+    KB_AUTO_UPDATE: boolean;
+    KB_UPDATE_COOLDOWN_MS: number;
+    SQS_QUEUE_URL?: string | undefined;
+    SESSIONS_TABLE?: string | undefined;
+    TEAMVIBE_API_URL?: string | undefined;
+    TEAMVIBE_POLLER_TOKEN?: string | undefined;
+}, {
+    AWS_REGION?: string | undefined;
+    SQS_QUEUE_URL?: string | undefined;
+    SESSIONS_TABLE?: string | undefined;
+    TEAMVIBE_API_URL?: string | undefined;
+    TEAMVIBE_POLLER_TOKEN?: string | undefined;
+    MAX_CONCURRENT_SESSIONS?: number | undefined;
+    POLL_WAIT_TIME_SECONDS?: number | undefined;
+    VISIBILITY_TIMEOUT_SECONDS?: number | undefined;
+    HEARTBEAT_INTERVAL_MS?: number | undefined;
+    CLAUDE_TIMEOUT_MS?: number | undefined;
+    STALE_LOCK_TIMEOUT_MS?: number | undefined;
+    KB_BASE_PATH?: string | undefined;
+    DEFAULT_KB_PATH?: string | undefined;
+    CLAUDE_CLI_PATH?: string | undefined;
+    KB_AUTO_UPDATE?: string | undefined;
+    KB_UPDATE_COOLDOWN_MS?: number | undefined;
+}>;
+export type Config = z.infer<typeof configSchema>;
+export declare function loadConfig(): Config;
+export declare const config: {
+    AWS_REGION: string;
+    MAX_CONCURRENT_SESSIONS: number;
+    POLL_WAIT_TIME_SECONDS: number;
+    VISIBILITY_TIMEOUT_SECONDS: number;
+    HEARTBEAT_INTERVAL_MS: number;
+    CLAUDE_TIMEOUT_MS: number;
+    STALE_LOCK_TIMEOUT_MS: number;
+    KB_BASE_PATH: string;
+    DEFAULT_KB_PATH: string;
+    CLAUDE_CLI_PATH: string;
+    KB_AUTO_UPDATE: boolean;
+    KB_UPDATE_COOLDOWN_MS: number;
+    SQS_QUEUE_URL?: string | undefined;
+    SESSIONS_TABLE?: string | undefined;
+    TEAMVIBE_API_URL?: string | undefined;
+    TEAMVIBE_POLLER_TOKEN?: string | undefined;
+};
+export {};

package/dist/config.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { config as dotenvConfig } from 'dotenv';
+dotenvConfig();
+const configSchema = z.object({
+    // AWS
+    AWS_REGION: z.string().default('eu-central-1'),
+    SQS_QUEUE_URL: z.string().optional(),
+    SESSIONS_TABLE: z.string().optional(),
+    // Token-based auth (alternative to direct AWS credentials)
+    TEAMVIBE_API_URL: z.string().optional(),
+    TEAMVIBE_POLLER_TOKEN: z.string().optional(),
+    // Poller settings
+    MAX_CONCURRENT_SESSIONS: z.coerce.number().default(5),
+    POLL_WAIT_TIME_SECONDS: z.coerce.number().default(20),
+    VISIBILITY_TIMEOUT_SECONDS: z.coerce.number().default(300),
+    HEARTBEAT_INTERVAL_MS: z.coerce.number().default(60000), // 1 minute
+    CLAUDE_TIMEOUT_MS: z.coerce.number().default(1800000), // 30 minutes
+    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(2100000), // 35 minutes
+    // Paths
+    KB_BASE_PATH: z.string().default(`${process.env['HOME']}/.teamvibe/knowledge-bases`),
+    DEFAULT_KB_PATH: z.string().default(`${process.env['HOME']}/.teamvibe/default-kb`),
+    CLAUDE_CLI_PATH: z.string().default('claude'),
+    // Knowledge base auto-update
+    KB_AUTO_UPDATE: z
+        .string()
+        .default('true')
+        .transform((v) => v.toLowerCase() === 'true'),
+    KB_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
+});
+export function loadConfig() {
+    const result = configSchema.safeParse(process.env);
+    if (!result.success) {
+        console.error('Configuration error:');
+        result.error.issues.forEach((issue) => {
+            console.error(`  ${issue.path.join('.')}: ${issue.message}`);
+        });
+        process.exit(1);
+    }
+    const data = result.data;
+    const isTokenMode = !!(data.TEAMVIBE_API_URL && data.TEAMVIBE_POLLER_TOKEN);
+    const isDirectMode = !!(data.SQS_QUEUE_URL && data.SESSIONS_TABLE);
+    if (!isTokenMode && !isDirectMode) {
+        console.error('Configuration error: Provide either TEAMVIBE_API_URL + TEAMVIBE_POLLER_TOKEN (token mode) or SQS_QUEUE_URL + SESSIONS_TABLE (direct mode)');
+        process.exit(1);
+    }
+    return data;
+}
+export const config = loadConfig();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};