@teamvibe/poller 0.2.0 → 0.2.2

package/dist/config.d.ts

@@ -27,8 +27,8 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH: z.ZodDefault<z.ZodString>;
     BRAIN_AUTO_UPDATE: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
     BRAIN_UPDATE_COOLDOWN_MS: z.ZodDefault<z.ZodNumber>;
-    MAINTENANCE_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
-    MAINTENANCE_CHECK_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
+    HEARTBEAT_CRON: z.ZodDefault<z.ZodString>;
+    MAINTENANCE_CRON: z.ZodDefault<z.ZodString>;
     MAINTENANCE_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
     AUTO_UPDATE_POLICY: z.ZodDefault<z.ZodEnum<["patch", "minor", "off"]>>;
     AUTO_UPDATE_SCHEDULE: z.ZodDefault<z.ZodString>;
@@ -56,8 +56,8 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
-    MAINTENANCE_INTERVAL_MS: number;
-    MAINTENANCE_CHECK_INTERVAL_MS: number;
+    HEARTBEAT_CRON: string;
+    MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
     AUTO_UPDATE_SCHEDULE: string;
@@ -91,8 +91,8 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH?: string | undefined;
     BRAIN_AUTO_UPDATE?: string | undefined;
     BRAIN_UPDATE_COOLDOWN_MS?: number | undefined;
-    MAINTENANCE_INTERVAL_MS?: number | undefined;
-    MAINTENANCE_CHECK_INTERVAL_MS?: number | undefined;
+    HEARTBEAT_CRON?: string | undefined;
+    MAINTENANCE_CRON?: string | undefined;
     MAINTENANCE_ENABLED?: string | undefined;
     AUTO_UPDATE_POLICY?: "patch" | "minor" | "off" | undefined;
     AUTO_UPDATE_SCHEDULE?: string | undefined;
@@ -123,8 +123,8 @@ export declare const config: {
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
-    MAINTENANCE_INTERVAL_MS: number;
-    MAINTENANCE_CHECK_INTERVAL_MS: number;
+    HEARTBEAT_CRON: string;
+    MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
     AUTO_UPDATE_SCHEDULE: string;

package/dist/config.js

@@ -42,9 +42,9 @@ const configSchema = z.object({
         .default('true')
         .transform((v) => v.toLowerCase() === 'true'),
     BRAIN_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
-    // Maintenance heartbeat
-    MAINTENANCE_INTERVAL_MS: z.coerce.number().default(21600000), // 6 hours between maintenance per brain
-    MAINTENANCE_CHECK_INTERVAL_MS: z.coerce.number().default(300000), // 5 min check loop
+    // Brain heartbeat & maintenance (cron-based)
+    HEARTBEAT_CRON: z.string().default('*/5 * * * *'), // Every 5 minutes
+    MAINTENANCE_CRON: z.string().default('30 3 * * *'), // Daily at 03:30 UTC
     MAINTENANCE_ENABLED: z.string().default('true').transform((v) => v.toLowerCase() === 'true'),
     // Auto-update settings
     AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('patch'),

package/dist/heartbeat-manager.d.ts

@@ -5,8 +5,10 @@ import type { TeamVibeQueueMessage } from './types.js';
  */
 export declare function registerBrain(msg: TeamVibeQueueMessage): void;
 /**
- * Start the periodic heartbeat check loop.
- * Checks every MAINTENANCE_CHECK_INTERVAL_MS whether any brain needs maintenance.
+ * Start the cron-based heartbeat and maintenance schedules.
+ *
+ * - Heartbeat: lightweight, frequent (default: every 5 min)
+ * - Maintenance: heavy, daily (default: 03:30 UTC)
  */
 export declare function startHeartbeatLoop(processMessageFn: (msg: {
     queueMessage: TeamVibeQueueMessage;
@@ -14,6 +16,6 @@ export declare function startHeartbeatLoop(processMessageFn: (msg: {
     messageId: string;
 }) => Promise<void>): void;
 /**
- * Stop the heartbeat loop (for shutdown).
+ * Stop the heartbeat and maintenance crons (for shutdown).
  */
 export declare function stopHeartbeatLoop(): void;

package/dist/heartbeat-manager.js

@@ -1,9 +1,11 @@
+import { Cron } from 'croner';
 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;
+let heartbeatJob = null;
+let maintenanceJob = null;
 /**
  * Register a brain from a real message so we know about it for heartbeats.
  * Called from processMessage() after brain path is resolved.
@@ -12,11 +14,9 @@ export function registerBrain(msg) {
     const brain = msg.teamvibe.brain;
     if (!brain?.brainId)
         return;
-    // Don't register from heartbeat messages (avoid self-referential loop)
-    if (msg.source === 'heartbeat')
+    // Don't register from heartbeat/maintenance messages (avoid self-referential loop)
+    if (msg.source === 'heartbeat' || msg.source === 'maintenance')
         return;
-    const existing = trackedBrains.get(brain.brainId);
-    // Update brain info but preserve lastHeartbeat if it exists
     trackedBrains.set(brain.brainId, {
         brainId: brain.brainId,
         gitRepoUrl: brain.gitRepoUrl,
@@ -25,82 +25,93 @@ export function registerBrain(msg) {
         botId: msg.teamvibe.botId,
         botToken: msg.teamvibe.botToken,
         channelId: msg.teamvibe.channelId,
-        lastHeartbeat: existing?.lastHeartbeat ?? 0,
     });
     logger.debug(`[Heartbeat] Registered brain: ${brain.brainId}`);
 }
 /**
- * Start the periodic heartbeat check loop.
- * Checks every MAINTENANCE_CHECK_INTERVAL_MS whether any brain needs maintenance.
+ * Send a synthetic message to all tracked brains.
+ */
+async function triggerAllBrains(source, processMessageFn) {
+    const now = Date.now();
+    for (const [brainId, info] of trackedBrains.entries()) {
+        if (isAtCapacity()) {
+            logger.debug(`[${source}] At capacity, skipping ${brainId}`);
+            continue;
+        }
+        logger.info(`[${source}] Triggering ${source} for brain ${brainId}`);
+        const syntheticMessage = {
+            id: `${source}_${brainId}_${now}`,
+            source,
+            thread_id: `${source}_${brainId}_${now}`,
+            sender: {
+                id: 'system',
+                name: 'System',
+            },
+            text: source,
+            attachments: [],
+            response_context: {},
+            type: 'message',
+            teamvibe: {
+                workspaceId: info.workspaceId,
+                botId: info.botId,
+                botToken: info.botToken,
+                channelId: info.channelId,
+                brain: {
+                    brainId: info.brainId,
+                    gitRepoUrl: info.gitRepoUrl,
+                    branch: info.branch,
+                },
+            },
+        };
+        try {
+            await processMessageFn({
+                queueMessage: syntheticMessage,
+                receiptHandle: '', // No SQS receipt for synthetic messages
+                messageId: syntheticMessage.id,
+            });
+        }
+        catch (error) {
+            logger.error(`[${source}] Failed for ${brainId}: ${error instanceof Error ? error.message : error}`);
+            emitError('session', `${source} failed for ${brainId}: ${error instanceof Error ? error.message : String(error)}`, {
+                channelId: info.channelId,
+                context: { brainId },
+            });
+        }
+    }
+}
+/**
+ * Start the cron-based heartbeat and maintenance schedules.
+ *
+ * - Heartbeat: lightweight, frequent (default: every 5 min)
+ * - Maintenance: heavy, daily (default: 03:30 UTC)
  */
 export function startHeartbeatLoop(processMessageFn) {
     if (!config.MAINTENANCE_ENABLED) {
         logger.info('[Heartbeat] Maintenance disabled via config');
         return;
     }
-    logger.info(`[Heartbeat] Starting heartbeat loop (check every ${config.MAINTENANCE_CHECK_INTERVAL_MS}ms, interval ${config.MAINTENANCE_INTERVAL_MS}ms)`);
-    heartbeatInterval = setInterval(async () => {
-        const now = Date.now();
-        for (const [brainId, info] of trackedBrains.entries()) {
-            const elapsed = now - info.lastHeartbeat;
-            if (elapsed < config.MAINTENANCE_INTERVAL_MS) {
-                continue;
-            }
-            if (isAtCapacity()) {
-                logger.debug(`[Heartbeat] At capacity, skipping heartbeat for ${brainId}`);
-                continue;
-            }
-            logger.info(`[Heartbeat] Triggering maintenance for brain ${brainId} (last: ${info.lastHeartbeat === 0 ? 'never' : `${Math.round(elapsed / 60000)}m ago`})`);
-            // Update lastHeartbeat immediately to prevent double-triggering
-            info.lastHeartbeat = now;
-            const syntheticMessage = {
-                id: `heartbeat_${brainId}_${now}`,
-                source: 'heartbeat',
-                thread_id: `heartbeat_${brainId}_${now}`,
-                sender: {
-                    id: 'system',
-                    name: 'System',
-                },
-                text: 'heartbeat',
-                attachments: [],
-                response_context: {},
-                type: 'message',
-                teamvibe: {
-                    workspaceId: info.workspaceId,
-                    botId: info.botId,
-                    botToken: info.botToken,
-                    channelId: info.channelId,
-                    brain: {
-                        brainId: info.brainId,
-                        gitRepoUrl: info.gitRepoUrl,
-                        branch: info.branch,
-                    },
-                },
-            };
-            try {
-                await processMessageFn({
-                    queueMessage: syntheticMessage,
-                    receiptHandle: '', // No SQS receipt for synthetic messages
-                    messageId: syntheticMessage.id,
-                });
-            }
-            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);
+    // Heartbeat cron — frequent, lightweight
+    logger.info(`[Heartbeat] Starting heartbeat cron: "${config.HEARTBEAT_CRON}"`);
+    heartbeatJob = new Cron(config.HEARTBEAT_CRON, { timezone: 'UTC', protect: true }, async () => {
+        await triggerAllBrains('heartbeat', processMessageFn);
+    });
+    // Maintenance cron — daily, heavy (consolidation, memory cleanup)
+    logger.info(`[Maintenance] Starting maintenance cron: "${config.MAINTENANCE_CRON}"`);
+    maintenanceJob = new Cron(config.MAINTENANCE_CRON, { timezone: 'UTC', protect: true }, async () => {
+        await triggerAllBrains('maintenance', processMessageFn);
+    });
 }
 /**
- * Stop the heartbeat loop (for shutdown).
+ * Stop the heartbeat and maintenance crons (for shutdown).
  */
 export function stopHeartbeatLoop() {
-    if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-        logger.info('[Heartbeat] Stopped heartbeat loop');
+    if (heartbeatJob) {
+        heartbeatJob.stop();
+        heartbeatJob = null;
+    }
+    if (maintenanceJob) {
+        maintenanceJob.stop();
+        maintenanceJob = null;
     }
+    logger.info('[Heartbeat] Stopped heartbeat & maintenance crons');
 }

package/dist/logger.js

@@ -14,8 +14,8 @@ if (!existsSync(SESSIONS_DIR)) {
 function formatDate(date) {
     return date.toISOString();
 }
-function writeToFile(level, message, ...args) {
-    const timestamp = formatDate(new Date());
+const now = () => formatDate(new Date());
+function writeToFile(level, message, timestamp, ...args) {
     const formattedArgs = args
         .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
         .join(' ');
@@ -35,8 +35,7 @@ export class SessionLogger {
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
         this.logFile = join(SESSIONS_DIR, `${timestamp}_${sessionId}.log`);
     }
-    write(level, message) {
-        const timestamp = formatDate(new Date());
+    write(level, message, timestamp) {
         const logLine = `[${timestamp}] [${level}] ${message}\n`;
         try {
             appendFileSync(this.logFile, logLine);
@@ -46,27 +45,30 @@ export class SessionLogger {
         }
     }
     info(message) {
-        console.log(`[${this.sessionId}] ${message}`);
-        this.write('INFO', message);
-        writeToFile('INFO', `[${this.sessionId}] ${message}`);
+        const ts = now();
+        console.log(`[${ts}] [${this.sessionId}] ${message}`);
+        this.write('INFO', message, ts);
+        writeToFile('INFO', `[${this.sessionId}] ${message}`, ts);
     }
     error(message) {
-        console.error(`[${this.sessionId}] ${message}`);
-        this.write('ERROR', message);
-        writeToFile('ERROR', `[${this.sessionId}] ${message}`);
+        const ts = now();
+        console.error(`[${ts}] [${this.sessionId}] ${message}`);
+        this.write('ERROR', message, ts);
+        writeToFile('ERROR', `[${this.sessionId}] ${message}`, ts);
     }
     claude(stream, message) {
+        const ts = now();
         const prefix = `[Claude ${stream}]`;
         if (stream === 'stderr') {
-            console.error(`[${this.sessionId}] ${prefix}`, message);
+            console.error(`[${ts}] [${this.sessionId}] ${prefix}`, message);
         }
         else {
-            console.log(`[${this.sessionId}] ${prefix}`, message);
+            console.log(`[${ts}] [${this.sessionId}] ${prefix}`, message);
         }
-        this.write(`CLAUDE_${stream.toUpperCase()}`, message);
+        this.write(`CLAUDE_${stream.toUpperCase()}`, message, ts);
     }
     logPrompt(prompt) {
-        this.write('PROMPT', `\n${'='.repeat(50)}\n${prompt}\n${'='.repeat(50)}`);
+        this.write('PROMPT', `\n${'='.repeat(50)}\n${prompt}\n${'='.repeat(50)}`, now());
     }
     getLogFile() {
         return this.logFile;
@@ -74,22 +76,26 @@ export class SessionLogger {
 }
 export const logger = {
     info(message, ...args) {
-        console.log(message, ...args);
-        writeToFile('INFO', message, ...args);
+        const ts = now();
+        console.log(`[${ts}] [INFO] ${message}`, ...args);
+        writeToFile('INFO', message, ts, ...args);
     },
     error(message, ...args) {
-        console.error(message, ...args);
-        writeToFile('ERROR', message, ...args);
+        const ts = now();
+        console.error(`[${ts}] [ERROR] ${message}`, ...args);
+        writeToFile('ERROR', message, ts, ...args);
     },
     warn(message, ...args) {
-        console.warn(message, ...args);
-        writeToFile('WARN', message, ...args);
+        const ts = now();
+        console.warn(`[${ts}] [WARN] ${message}`, ...args);
+        writeToFile('WARN', message, ts, ...args);
     },
     debug(message, ...args) {
+        const ts = now();
         if (process.env['DEBUG']) {
-            console.debug(message, ...args);
+            console.debug(`[${ts}] [DEBUG] ${message}`, ...args);
         }
-        writeToFile('DEBUG', message, ...args);
+        writeToFile('DEBUG', message, ts, ...args);
     },
     createSession(sessionId) {
         return new SessionLogger(sessionId);

package/dist/poller.js

@@ -200,7 +200,7 @@ async function processMessage(received) {
     const threadId = queueMessage.thread_id;
     const sessionLog = logger.createSession(logSessionId);
     // Fetch user info if we only have ID
-    if (queueMessage.source !== 'cron' && queueMessage.source !== 'heartbeat' &&
+    if (queueMessage.source !== 'cron' && queueMessage.source !== 'heartbeat' && queueMessage.source !== 'maintenance' &&
         queueMessage.sender.name === 'Unknown User' &&
         queueMessage.sender.id !== 'unknown') {
         const userInfo = await getUserInfo(queueMessage.teamvibe.botToken, queueMessage.sender.id);

package/dist/types.d.ts

@@ -7,7 +7,7 @@ export interface ControlMessage {
 export type QueueMessage = TeamVibeQueueMessage | ControlMessage;
 export interface TeamVibeQueueMessage {
     id: string;
-    source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'webhook';
+    source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'maintenance' | 'webhook';
     thread_id: string;
     sender: {
         id: string;

package/package.json

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

package/dist/control-handler.test.d.ts

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

package/dist/control-handler.test.js

@@ -1,74 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { isControlMessage } from './control-handler.js';
-import { classifyUpdate } from './auto-update.js';
-describe('isControlMessage', () => {
-    test('valid restart message', () => {
-        expect(isControlMessage({ source: 'control', action: 'restart' })).toBe(true);
-    });
-    test('valid update message', () => {
-        expect(isControlMessage({ source: 'control', action: 'update' })).toBe(true);
-    });
-    test('valid update with targetVersion', () => {
-        expect(isControlMessage({ source: 'control', action: 'update', targetVersion: '1.2.3' })).toBe(true);
-    });
-    test('rejects non-control source', () => {
-        expect(isControlMessage({ source: 'slack', action: 'restart' })).toBe(false);
-    });
-    test('rejects unknown action', () => {
-        expect(isControlMessage({ source: 'control', action: 'delete' })).toBe(false);
-    });
-    test('rejects null', () => {
-        expect(isControlMessage(null)).toBe(false);
-    });
-    test('rejects undefined', () => {
-        expect(isControlMessage(undefined)).toBe(false);
-    });
-    test('rejects string', () => {
-        expect(isControlMessage('control')).toBe(false);
-    });
-    test('rejects empty object', () => {
-        expect(isControlMessage({})).toBe(false);
-    });
-    test('rejects regular queue message', () => {
-        expect(isControlMessage({
-            id: '123',
-            source: 'cron',
-            thread_id: 'thread1',
-            sender: { id: 'user1', name: 'Test' },
-            text: 'hello',
-        })).toBe(false);
-    });
-});
-describe('classifyUpdate', () => {
-    test('detects patch update', () => {
-        expect(classifyUpdate('1.2.3', '1.2.4')).toBe('patch');
-    });
-    test('detects minor update', () => {
-        expect(classifyUpdate('1.2.3', '1.3.0')).toBe('minor');
-    });
-    test('detects major update', () => {
-        expect(classifyUpdate('1.2.3', '2.0.0')).toBe('major');
-    });
-    test('returns null for same version', () => {
-        expect(classifyUpdate('1.2.3', '1.2.3')).toBeNull();
-    });
-    test('returns null for downgrade (patch)', () => {
-        expect(classifyUpdate('1.2.4', '1.2.3')).toBeNull();
-    });
-    test('returns null for downgrade (minor)', () => {
-        expect(classifyUpdate('1.3.0', '1.2.5')).toBeNull();
-    });
-    test('returns null for downgrade (major)', () => {
-        expect(classifyUpdate('2.0.0', '1.9.9')).toBeNull();
-    });
-    test('handles zero versions', () => {
-        expect(classifyUpdate('0.0.1', '0.0.2')).toBe('patch');
-        expect(classifyUpdate('0.1.0', '0.2.0')).toBe('minor');
-    });
-    test('minor update with different patch', () => {
-        expect(classifyUpdate('1.2.3', '1.3.5')).toBe('minor');
-    });
-    test('major update with different minor/patch', () => {
-        expect(classifyUpdate('1.2.3', '2.1.0')).toBe('major');
-    });
-});