@teamvibe/poller 0.2.0 → 0.2.1

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/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.1",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {