@teamvibe/poller 0.1.68 → 0.2.0

package/dist/poller.js

@@ -10,8 +10,45 @@ import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
 import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
 import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed } from './inbox-manager.js';
+import { Cron } from 'croner';
+import { isControlMessage, handleControlMessage } from './control-handler.js';
+import { checkForUpdate } from './auto-update.js';
 // Track active message processing
 const processingMessages = new Set();
+// Poller auto-update cron (separate from brain heartbeats)
+let autoUpdateJob = null;
+function startAutoUpdateCron() {
+    const schedule = config.AUTO_UPDATE_SCHEDULE;
+    const match = schedule.match(/^(\d{2}):(\d{2})$/);
+    if (!match || config.AUTO_UPDATE_POLICY === 'off') {
+        if (config.AUTO_UPDATE_POLICY !== 'off') {
+            logger.warn(`[AutoUpdate] Invalid AUTO_UPDATE_SCHEDULE: "${schedule}", expected "HH:MM"`);
+        }
+        return;
+    }
+    // Convert "HH:MM" to cron expression: "MM HH * * *"
+    const cronExpr = `${match[2]} ${match[1]} * * *`;
+    logger.info(`[AutoUpdate] Scheduled daily at ${schedule} UTC (cron: ${cronExpr}), policy: ${config.AUTO_UPDATE_POLICY}`);
+    autoUpdateJob = new Cron(cronExpr, { timezone: 'UTC' }, async () => {
+        try {
+            const shouldRestart = await checkForUpdate();
+            if (shouldRestart) {
+                logger.info('[AutoUpdate] Update applied, restarting...');
+                await flushEventQueue();
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            logger.error(`[AutoUpdate] Check error: ${error instanceof Error ? error.message : error}`);
+        }
+    });
+}
+function stopAutoUpdateCron() {
+    if (autoUpdateJob) {
+        autoUpdateJob.stop();
+        autoUpdateJob = null;
+    }
+}
 // Track which threads have an active processing loop
 const activeLoops = new Set();
 async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
@@ -290,7 +327,20 @@ async function pollLoop() {
             if (duplicates.length > 0) {
                 logger.info(`Deduplicated: ${messages.length} -> ${unique.length} message(s)`);
             }
-            const processPromises = unique.map((msg) => processMessage(msg).catch((error) => {
+            // Handle control messages immediately (restart/update) — no Claude session needed
+            const regularMessages = [];
+            for (const msg of unique) {
+                const raw = msg.queueMessage;
+                if (isControlMessage(raw)) {
+                    logger.info(`[Control] Received control message: ${raw.action}`);
+                    await deleteMessage(msg.receiptHandle);
+                    await handleControlMessage(raw);
+                    // If we get here, the action didn't trigger an exit (e.g. update failed pre-check)
+                    continue;
+                }
+                regularMessages.push(msg);
+            }
+            const processPromises = regularMessages.map((msg) => processMessage(msg).catch((error) => {
                 logger.error(`Failed to process message ${msg.messageId}:`, error);
             }));
             // Don't await - let them run in parallel
@@ -314,6 +364,7 @@ async function shutdown(signal) {
     logger.info(`${signal} received, shutting down gracefully...`);
     stopRefresh();
     stopHeartbeatLoop();
+    stopAutoUpdateCron();
     stopEventQueue();
     // Kill all active Claude child processes
     await killAllActiveProcesses();
@@ -351,5 +402,6 @@ export async function startPoller() {
     await ensureDirectories();
     await ensureBaseBrain();
     startHeartbeatLoop(processMessage);
+    startAutoUpdateCron();
     await pollLoop();
 }

package/dist/types.d.ts

@@ -1,3 +1,10 @@
+export interface ControlMessage {
+    id: string;
+    source: 'control';
+    action: 'restart' | 'update';
+    targetVersion?: string;
+}
+export type QueueMessage = TeamVibeQueueMessage | ControlMessage;
 export interface TeamVibeQueueMessage {
     id: string;
     source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'webhook';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.68",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
@@ -24,6 +24,7 @@
     "@aws-sdk/client-sqs": "^3.470.0",
     "@aws-sdk/lib-dynamodb": "^3.470.0",
     "@slack/web-api": "^7.0.0",
+    "croner": "^10.0.1",
     "dotenv": "^17.2.3",
     "zod": "^3.22.0"
   },

package/dist/kb-manager.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/mailbox-manager.d.ts

@@ -1,26 +0,0 @@
-/**
- * Write a new message to the mailbox.
- * Returns the filename of the created message file.
- */
-export declare function writeMessage(brainPath: string, threadId: string, content: string): string;
-/**
- * Pick the oldest message from processing/ (crash recovery) or new/.
- * If found in new/, moves it to processing/.
- * Returns { filename, content } or null if no messages.
- */
-export declare function pickNextMessage(brainPath: string, threadId: string): {
-    filename: string;
-    content: string;
-} | null;
-/**
- * Delete a message file from processing/ (marks it as done).
- */
-export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
-/**
- * Check if there are unprocessed messages in new/ or processing/.
- */
-export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;
-/**
- * Get the mailbox new/ directory path for use in Claude's system prompt.
- */
-export declare function getMailboxNewPath(brainPath: string, threadId: string): string;

package/dist/mailbox-manager.js

@@ -1,95 +0,0 @@
-import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import { logger } from './logger.js';
-const MAILBOX_DIR = '.mailbox';
-const NEW_DIR = 'new';
-const PROCESSING_DIR = 'processing';
-function getMailboxPath(brainPath, threadId) {
-    return join(brainPath, MAILBOX_DIR, threadId);
-}
-function ensureMailboxDirs(brainPath, threadId) {
-    const mailbox = getMailboxPath(brainPath, threadId);
-    mkdirSync(join(mailbox, NEW_DIR), { recursive: true });
-    mkdirSync(join(mailbox, PROCESSING_DIR), { recursive: true });
-}
-/**
- * Write a new message to the mailbox.
- * Returns the filename of the created message file.
- */
-export function writeMessage(brainPath, threadId, content) {
-    ensureMailboxDirs(brainPath, threadId);
-    const timestamp = process.hrtime.bigint().toString();
-    const filename = `${timestamp}.txt`;
-    const filepath = join(getMailboxPath(brainPath, threadId), NEW_DIR, filename);
-    writeFileSync(filepath, content, 'utf-8');
-    logger.info(`[Mailbox] Wrote message: ${filename} to ${getMailboxPath(brainPath, threadId)}/new/ (${content.length} chars, threadId=${threadId})`);
-    return filename;
-}
-/**
- * Pick the oldest message from processing/ (crash recovery) or new/.
- * If found in new/, moves it to processing/.
- * Returns { filename, content } or null if no messages.
- */
-export function pickNextMessage(brainPath, threadId) {
-    ensureMailboxDirs(brainPath, threadId);
-    const mailbox = getMailboxPath(brainPath, threadId);
-    const processingDir = join(mailbox, PROCESSING_DIR);
-    const newDir = join(mailbox, NEW_DIR);
-    // First check processing/ (crash recovery)
-    const processingFiles = readdirSync(processingDir).filter(f => f.endsWith('.txt')).sort();
-    if (processingFiles.length > 0) {
-        const filename = processingFiles[0];
-        const content = readFileSync(join(processingDir, filename), 'utf-8');
-        logger.info(`[Mailbox] Resuming processing message: ${filename}`);
-        return { filename, content };
-    }
-    // Then check new/
-    const newFiles = readdirSync(newDir).filter(f => f.endsWith('.txt')).sort();
-    if (newFiles.length > 0) {
-        const filename = newFiles[0];
-        const srcPath = join(newDir, filename);
-        const dstPath = join(processingDir, filename);
-        const content = readFileSync(srcPath, 'utf-8');
-        renameSync(srcPath, dstPath);
-        logger.info(`[Mailbox] Picked message: ${filename} (moved to processing)`);
-        return { filename, content };
-    }
-    return null;
-}
-/**
- * Delete a message file from processing/ (marks it as done).
- */
-export function markProcessed(brainPath, threadId, filename) {
-    const filepath = join(getMailboxPath(brainPath, threadId), PROCESSING_DIR, filename);
-    try {
-        if (existsSync(filepath)) {
-            unlinkSync(filepath);
-            logger.info(`[Mailbox] Deleted processed message: ${filename}`);
-        }
-    }
-    catch (error) {
-        logger.warn(`[Mailbox] Failed to delete ${filename}: ${error}`);
-    }
-}
-/**
- * Check if there are unprocessed messages in new/ or processing/.
- */
-export function hasUnprocessed(brainPath, threadId) {
-    const mailbox = getMailboxPath(brainPath, threadId);
-    const newDir = join(mailbox, NEW_DIR);
-    const processingDir = join(mailbox, PROCESSING_DIR);
-    try {
-        const newCount = existsSync(newDir) ? readdirSync(newDir).filter(f => f.endsWith('.txt')).length : 0;
-        const procCount = existsSync(processingDir) ? readdirSync(processingDir).filter(f => f.endsWith('.txt')).length : 0;
-        return (newCount + procCount) > 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the mailbox new/ directory path for use in Claude's system prompt.
- */
-export function getMailboxNewPath(brainPath, threadId) {
-    return join(getMailboxPath(brainPath, threadId), NEW_DIR);
-}

package/dist/scripts/add-reaction.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Add an emoji reaction to the original message.
- *
- * Usage:
- *   node add-reaction.js emoji_name
- *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-export {};

package/dist/scripts/add-reaction.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-/**
- * Add an emoji reaction to the original message.
- *
- * Usage:
- *   node add-reaction.js emoji_name
- *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, messageTs, positional } = parseArgs();
-const emoji = positional[0];
-if (!emoji)
-    fail('Emoji name required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!messageTs)
-    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
-async function main() {
-    await slack.reactions.add({ channel: channel, timestamp: messageTs, name: emoji });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/lib/slack-client.d.ts

@@ -1,16 +0,0 @@
-import { WebClient } from '@slack/web-api';
-export declare function fail(error: string): never;
-export declare function succeed(data?: Record<string, unknown>): never;
-export declare const slack: WebClient;
-/**
- * Parse CLI args: extracts known --flags and returns remaining positional args.
- * Supports both --flag value and --flag=value syntax.
- * Falls back to env vars for channel/thread_ts/message_ts.
- */
-export declare function parseArgs(argv?: string[]): {
-    channel: string | undefined;
-    threadTs: string | undefined;
-    messageTs: string | undefined;
-    positional: string[];
-    textFromFlag: string | undefined;
-};

package/dist/scripts/lib/slack-client.js

@@ -1,48 +0,0 @@
-import { WebClient } from '@slack/web-api';
-const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
-export function fail(error) {
-    console.log(JSON.stringify({ ok: false, error }));
-    process.exit(1);
-}
-export function succeed(data = {}) {
-    console.log(JSON.stringify({ ok: true, ...data }));
-    process.exit(0);
-}
-if (!BOT_TOKEN)
-    fail('SLACK_BOT_TOKEN not set');
-export const slack = new WebClient(BOT_TOKEN);
-/**
- * Parse CLI args: extracts known --flags and returns remaining positional args.
- * Supports both --flag value and --flag=value syntax.
- * Falls back to env vars for channel/thread_ts/message_ts.
- */
-export function parseArgs(argv = process.argv.slice(2)) {
-    const flags = {};
-    const positional = [];
-    const knownFlags = ['--channel', '--thread_ts', '--thread-ts', '--message_ts', '--message-ts', '--text'];
-    let i = 0;
-    while (i < argv.length) {
-        const arg = argv[i];
-        // --flag=value
-        const eqMatch = arg.match(/^(--[\w-]+)=(.*)$/);
-        if (eqMatch) {
-            flags[eqMatch[1]] = eqMatch[2];
-            i++;
-            continue;
-        }
-        // --flag value
-        if (knownFlags.includes(arg) && i + 1 < argv.length) {
-            flags[arg] = argv[i + 1];
-            i += 2;
-            continue;
-        }
-        positional.push(arg);
-        i++;
-    }
-    // If --text was provided, use it (and any remaining positional after it)
-    const textFromFlag = flags['--text'];
-    const channel = flags['--channel'] || process.env['SLACK_CHANNEL'];
-    const threadTs = flags['--thread_ts'] || flags['--thread-ts'] || process.env['SLACK_THREAD_TS'];
-    const messageTs = flags['--message_ts'] || flags['--message-ts'] || process.env['SLACK_MESSAGE_TS'];
-    return { channel, threadTs, messageTs, positional, textFromFlag };
-}

package/dist/scripts/read-thread.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Read thread history from a Slack thread.
- *
- * Usage:
- *   node read-thread.js [limit]
- *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
- */
-export {};

package/dist/scripts/read-thread.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-/**
- * Read thread history from a Slack thread.
- *
- * Usage:
- *   node read-thread.js [limit]
- *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional } = parseArgs();
-const limit = parseInt(positional[0] || '20', 10);
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!threadTs)
-    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
-async function main() {
-    const result = await slack.conversations.replies({ channel: channel, ts: threadTs, 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 });
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/remove-reaction.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Remove an emoji reaction from the original message.
- *
- * Usage:
- *   node remove-reaction.js emoji_name
- *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-export {};

package/dist/scripts/remove-reaction.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-/**
- * Remove an emoji reaction from the original message.
- *
- * Usage:
- *   node remove-reaction.js emoji_name
- *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, messageTs, positional } = parseArgs();
-const emoji = positional[0];
-if (!emoji)
-    fail('Emoji name required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!messageTs)
-    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
-async function main() {
-    await slack.reactions.remove({ channel: channel, timestamp: messageTs, name: emoji });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/send-message.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Send a message to a Slack thread.
- *
- * Usage:
- *   node send-message.js "Your message here"
- *   node send-message.js --text "Your message here"
- *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
- */
-export {};

package/dist/scripts/send-message.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-/**
- * Send a message to a Slack thread.
- *
- * Usage:
- *   node send-message.js "Your message here"
- *   node send-message.js --text "Your message here"
- *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional, textFromFlag } = parseArgs();
-const text = textFromFlag || positional.join(' ');
-if (!text)
-    fail('Message text required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!threadTs)
-    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
-async function main() {
-    console.error(`[slack] send_message: channel=${channel}, thread_ts=${threadTs}`);
-    const result = await slack.chat.postMessage({
-        channel: channel,
-        thread_ts: threadTs,
-        text,
-        unfurl_links: false,
-        unfurl_media: false,
-    });
-    console.error(`[slack] posted: ts=${result.ts}`);
-    succeed({ ts: result.ts });
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/set-status.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Set the assistant thread status.
- *
- * Usage:
- *   node set-status.js "Status text"
- */
-export {};

package/dist/scripts/set-status.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * Set the assistant thread status.
- *
- * Usage:
- *   node set-status.js "Status text"
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional } = parseArgs();
-const status = positional.join(' ');
-if (!channel)
-    fail('Channel required');
-if (!threadTs)
-    fail('Thread TS required');
-async function main() {
-    await slack.apiCall('assistant.threads.setStatus', { channel_id: channel, thread_ts: threadTs, status });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));