@teamvibe/poller 0.1.68 → 0.1.69

package/dist/auto-update.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compare two semver versions. Returns:
+ * - 'patch' if only patch differs (1.2.3 → 1.2.4)
+ * - 'minor' if minor differs (1.2.3 → 1.3.0)
+ * - 'major' if major differs (1.2.3 → 2.0.0)
+ * - null if same or current is newer
+ */
+export declare function classifyUpdate(current: string, latest: string): 'patch' | 'minor' | 'major' | null;
+/**
+ * Check for updates and apply if within policy.
+ * Called by the cron job defined in poller.ts.
+ *
+ * Returns true if an update was applied and poller should restart (exit 0).
+ */
+export declare function checkForUpdate(): Promise<boolean>;

package/dist/auto-update.js

@@ -0,0 +1,151 @@
+import { execSync } from 'child_process';
+import { config, POLLER_VERSION } from './config.js';
+import { logger } from './logger.js';
+import { emitEvent } from './event-queue.js';
+import { doctor } from './cli/doctor.js';
+const UPDATE_TIMEOUT_MS = 120_000; // 2 minutes
+const MAX_CONSECUTIVE_FAILURES = 3;
+let consecutiveFailures = 0;
+/**
+ * Compare two semver versions. Returns:
+ * - 'patch' if only patch differs (1.2.3 → 1.2.4)
+ * - 'minor' if minor differs (1.2.3 → 1.3.0)
+ * - 'major' if major differs (1.2.3 → 2.0.0)
+ * - null if same or current is newer
+ */
+export function classifyUpdate(current, latest) {
+    const [curMajor, curMinor, curPatch] = current.split('.').map(Number);
+    const [latMajor, latMinor, latPatch] = latest.split('.').map(Number);
+    if (latMajor > curMajor)
+        return 'major';
+    if (latMajor < curMajor)
+        return null;
+    if (latMinor > curMinor)
+        return 'minor';
+    if (latMinor < curMinor)
+        return null;
+    if (latPatch > curPatch)
+        return 'patch';
+    return null;
+}
+/**
+ * Fetch the latest version from npm registry.
+ */
+function getLatestVersion() {
+    try {
+        const output = execSync('npm view @teamvibe/poller version', {
+            encoding: 'utf-8',
+            timeout: 15_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim();
+    }
+    catch (error) {
+        logger.warn(`[AutoUpdate] Failed to check npm registry: ${error instanceof Error ? error.message : error}`);
+        return null;
+    }
+}
+/**
+ * Check for updates and apply if within policy.
+ * Called by the cron job defined in poller.ts.
+ *
+ * Returns true if an update was applied and poller should restart (exit 0).
+ */
+export async function checkForUpdate() {
+    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        logger.warn(`[AutoUpdate] Disabled — ${consecutiveFailures} consecutive failures`);
+        emitEvent('poller.autoupdate.disabled', 'system', {
+            reason: 'max-failures-reached',
+            failures: consecutiveFailures,
+            currentVersion: POLLER_VERSION,
+        });
+        return false;
+    }
+    logger.info(`[AutoUpdate] Checking for updates (current: ${POLLER_VERSION}, policy: ${config.AUTO_UPDATE_POLICY})`);
+    // Check npm registry for latest version
+    const latestVersion = getLatestVersion();
+    if (!latestVersion) {
+        return false;
+    }
+    const updateType = classifyUpdate(POLLER_VERSION, latestVersion);
+    if (!updateType) {
+        logger.info(`[AutoUpdate] Already on latest version (${POLLER_VERSION})`);
+        return false;
+    }
+    // Check if update type is within policy
+    const policyAllows = config.AUTO_UPDATE_POLICY === 'minor'
+        ? updateType === 'patch' || updateType === 'minor'
+        : updateType === 'patch'; // policy === 'patch'
+    if (!policyAllows) {
+        logger.info(`[AutoUpdate] ${updateType} update available (${POLLER_VERSION} → ${latestVersion}) but policy is "${config.AUTO_UPDATE_POLICY}", skipping`);
+        return false;
+    }
+    logger.info(`[AutoUpdate] ${updateType} update available: ${POLLER_VERSION} → ${latestVersion}`);
+    // Step 1: Pre-check
+    logger.info('[AutoUpdate] Running pre-update health check...');
+    const preCheckOk = await doctor();
+    if (!preCheckOk) {
+        logger.warn('[AutoUpdate] Pre-check failed, skipping update');
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.failed', 'system', {
+            reason: 'pre-check-failed',
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+        });
+        return false;
+    }
+    // Step 2: Install
+    logger.info(`[AutoUpdate] Installing @teamvibe/poller@${latestVersion}...`);
+    try {
+        execSync(`npm install -g @teamvibe/poller@${latestVersion}`, {
+            timeout: UPDATE_TIMEOUT_MS,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`[AutoUpdate] Install failed: ${errorMsg}`);
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.failed', 'system', {
+            reason: 'install-failed',
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+            error: errorMsg,
+        });
+        return false;
+    }
+    // Step 3: Post-check
+    logger.info('[AutoUpdate] Running post-update health check...');
+    const postCheckOk = await doctor();
+    if (!postCheckOk) {
+        logger.warn(`[AutoUpdate] Post-check failed, rolling back to ${POLLER_VERSION}...`);
+        try {
+            execSync(`npm install -g @teamvibe/poller@${POLLER_VERSION}`, {
+                timeout: UPDATE_TIMEOUT_MS,
+                stdio: 'pipe',
+                encoding: 'utf-8',
+            });
+            logger.info(`[AutoUpdate] Rolled back to ${POLLER_VERSION}`);
+        }
+        catch (rollbackError) {
+            logger.error(`[AutoUpdate] CRITICAL: Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : rollbackError}`);
+        }
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.rolledback', 'system', {
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+            reason: 'post-check-failed',
+        });
+        return false;
+    }
+    // Success
+    consecutiveFailures = 0;
+    logger.info(`[AutoUpdate] Successfully updated ${POLLER_VERSION} → ${latestVersion}. Restart required.`);
+    emitEvent('poller.autoupdate.success', 'system', {
+        previousVersion: POLLER_VERSION,
+        newVersion: latestVersion,
+        updateType,
+    });
+    return true;
+}

package/dist/cli/commands.js

@@ -5,6 +5,7 @@ import { update } from './update.js';
 import { logs } from './logs.js';
 import { start, stop, restart, status } from './service.js';
 import { reset } from './reset.js';
+import { doctor } from './doctor.js';
 function showHelp() {
     console.log(`TeamVibe Poller
 
@@ -16,6 +17,7 @@ Commands:
                   Flags: --token <token> --claude-token <token> [--api-url <url>] [--max-concurrent <n>]
   uninstall       Remove the launchd service
   update          Update to the latest version and restart
+  doctor          Run health checks (verify installation & configuration)
   start           Start the installed service
   stop            Stop the installed service
   restart         Restart the installed service
@@ -57,6 +59,11 @@ export async function handleCommand(command) {
         case 'restart':
             restart();
             break;
+        case 'doctor': {
+            const healthy = await doctor();
+            process.exit(healthy ? 0 : 1);
+            break;
+        }
         case 'reset':
             await reset();
             break;

package/dist/cli/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<boolean>;

package/dist/cli/doctor.js

@@ -0,0 +1,195 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { PLIST_PATH, SERVICE_LABEL, TEAMVIBE_DIR, LOGS_DIR } from './plist.js';
+function check(name, fn) {
+    try {
+        const result = fn();
+        if (result === true) {
+            return { name, ok: true, message: 'OK' };
+        }
+        return { name, ok: true, message: result };
+    }
+    catch (error) {
+        return { name, ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function checkNodeVersion() {
+    return check('Node.js version', () => {
+        const version = process.version;
+        const major = parseInt(version.slice(1).split('.')[0], 10);
+        if (major < 18) {
+            throw new Error(`Node.js ${version} is below minimum (v18). Please upgrade.`);
+        }
+        return `${version} (>= v18)`;
+    });
+}
+function checkTeamVibeDir() {
+    return check('TeamVibe directory', () => {
+        if (!fs.existsSync(TEAMVIBE_DIR)) {
+            throw new Error(`${TEAMVIBE_DIR} does not exist. Run 'poller install' first.`);
+        }
+        return TEAMVIBE_DIR;
+    });
+}
+function checkEnvFile() {
+    return check('Environment config', () => {
+        const envPath = path.join(TEAMVIBE_DIR, '.env');
+        if (!fs.existsSync(envPath)) {
+            throw new Error(`${envPath} not found. Run 'poller install' to configure.`);
+        }
+        const content = fs.readFileSync(envPath, 'utf-8');
+        const hasToken = content.includes('TEAMVIBE_POLLER_TOKEN');
+        const hasDirect = content.includes('SQS_QUEUE_URL') && content.includes('SESSIONS_TABLE');
+        if (!hasToken && !hasDirect) {
+            throw new Error('Missing auth configuration (TEAMVIBE_POLLER_TOKEN or SQS_QUEUE_URL + SESSIONS_TABLE)');
+        }
+        return hasToken ? 'Token mode configured' : 'Direct mode configured';
+    });
+}
+function checkLaunchdPlist() {
+    return check('Launchd plist', () => {
+        if (process.platform !== 'darwin') {
+            return 'Skipped (not macOS)';
+        }
+        if (!fs.existsSync(PLIST_PATH)) {
+            throw new Error(`Plist not found at ${PLIST_PATH}. Run 'poller install'.`);
+        }
+        const content = fs.readFileSync(PLIST_PATH, 'utf-8');
+        if (!content.includes('<key>KeepAlive</key>')) {
+            throw new Error('KeepAlive not set in plist — poller will not auto-restart on exit');
+        }
+        if (content.includes('/_npx/')) {
+            throw new Error('Plist references stale npx cache path. Run \'poller update\' to fix.');
+        }
+        return 'Installed with KeepAlive';
+    });
+}
+function checkServiceRunning() {
+    return check('Service status', () => {
+        if (process.platform !== 'darwin') {
+            return 'Skipped (not macOS)';
+        }
+        try {
+            const output = execSync(`launchctl list | grep ${SERVICE_LABEL}`, { encoding: 'utf-8' });
+            if (output.trim()) {
+                const parts = output.trim().split('\t');
+                const pid = parts[0];
+                const lastExitStatus = parts[1];
+                if (pid === '-') {
+                    throw new Error(`Service loaded but not running (last exit: ${lastExitStatus})`);
+                }
+                return `Running (PID: ${pid})`;
+            }
+            throw new Error('Service not loaded');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Service')) {
+                throw error;
+            }
+            throw new Error('Service not loaded in launchd');
+        }
+    });
+}
+function checkLogsDir() {
+    return check('Logs directory', () => {
+        if (!fs.existsSync(LOGS_DIR)) {
+            throw new Error(`${LOGS_DIR} does not exist`);
+        }
+        const stdoutLog = path.join(LOGS_DIR, 'poller.stdout.log');
+        const stderrLog = path.join(LOGS_DIR, 'poller.stderr.log');
+        const hasStdout = fs.existsSync(stdoutLog);
+        const hasStderr = fs.existsSync(stderrLog);
+        if (!hasStdout && !hasStderr) {
+            return 'Directory exists but no log files yet';
+        }
+        return 'OK';
+    });
+}
+function checkClaudeCli() {
+    return check('Claude CLI', () => {
+        try {
+            const output = execSync('which claude', { encoding: 'utf-8' }).trim();
+            if (!output) {
+                throw new Error('Claude CLI not found in PATH');
+            }
+            // Try to get version
+            try {
+                const version = execSync('claude --version 2>/dev/null', { encoding: 'utf-8' }).trim();
+                return `${output} (${version})`;
+            }
+            catch {
+                return output;
+            }
+        }
+        catch {
+            throw new Error('Claude CLI not found in PATH. Install Claude Code first.');
+        }
+    });
+}
+function checkBrainsDir() {
+    return check('Brains directory', () => {
+        const brainsPath = path.join(TEAMVIBE_DIR, 'brains');
+        if (!fs.existsSync(brainsPath)) {
+            return 'Not yet created (will be created on first message)';
+        }
+        const brains = fs.readdirSync(brainsPath).filter(f => {
+            const stat = fs.statSync(path.join(brainsPath, f));
+            return stat.isDirectory();
+        });
+        return `${brains.length} brain(s) cloned`;
+    });
+}
+function checkDiskSpace() {
+    return check('Disk space', () => {
+        try {
+            const output = execSync(`df -h "${TEAMVIBE_DIR}" | tail -1`, { encoding: 'utf-8' }).trim();
+            const parts = output.split(/\s+/);
+            const available = parts[3];
+            const capacityStr = parts[4]?.replace('%', '');
+            const capacity = parseInt(capacityStr || '0', 10);
+            if (capacity > 95) {
+                throw new Error(`Disk ${capacity}% full — only ${available} available`);
+            }
+            if (capacity > 85) {
+                return `Warning: ${capacity}% used (${available} available)`;
+            }
+            return `${available} available (${capacity}% used)`;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Disk'))
+                throw error;
+            throw new Error('Could not check disk space');
+        }
+    });
+}
+export async function doctor() {
+    console.log('TeamVibe Poller - Health Check\n');
+    const results = [
+        checkNodeVersion(),
+        checkTeamVibeDir(),
+        checkEnvFile(),
+        checkLaunchdPlist(),
+        checkServiceRunning(),
+        checkLogsDir(),
+        checkClaudeCli(),
+        checkBrainsDir(),
+        checkDiskSpace(),
+    ];
+    let hasFailure = false;
+    for (const result of results) {
+        const icon = result.ok ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+        console.log(`  ${icon} ${result.name}: ${result.message}`);
+        if (!result.ok)
+            hasFailure = true;
+    }
+    console.log('');
+    if (hasFailure) {
+        console.log('\x1b[31mSome checks failed. Fix the issues above before proceeding.\x1b[0m');
+        return false;
+    }
+    else {
+        console.log('\x1b[32mAll checks passed. Poller is healthy.\x1b[0m');
+        return true;
+    }
+}

package/dist/config.d.ts

@@ -30,6 +30,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     MAINTENANCE_CHECK_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     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>;
 }, "strip", z.ZodTypeAny, {
     AWS_REGION: string;
     TEAMVIBE_API_URL: string;
@@ -57,6 +59,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS: number;
     MAINTENANCE_CHECK_INTERVAL_MS: number;
     MAINTENANCE_ENABLED: boolean;
+    AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
+    AUTO_UPDATE_SCHEDULE: string;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;
@@ -90,6 +94,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS?: number | undefined;
     MAINTENANCE_CHECK_INTERVAL_MS?: number | undefined;
     MAINTENANCE_ENABLED?: string | undefined;
+    AUTO_UPDATE_POLICY?: "patch" | "minor" | "off" | undefined;
+    AUTO_UPDATE_SCHEDULE?: string | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
 export declare function loadConfig(): Config;
@@ -120,6 +126,8 @@ export declare const config: {
     MAINTENANCE_INTERVAL_MS: number;
     MAINTENANCE_CHECK_INTERVAL_MS: number;
     MAINTENANCE_ENABLED: boolean;
+    AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
+    AUTO_UPDATE_SCHEDULE: string;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;

package/dist/config.js

@@ -46,6 +46,9 @@ const configSchema = z.object({
     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
     MAINTENANCE_ENABLED: z.string().default('true').transform((v) => v.toLowerCase() === 'true'),
+    // Auto-update settings
+    AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('patch'),
+    AUTO_UPDATE_SCHEDULE: z.string().default('03:00'), // HH:MM in UTC — daily check time
 });
 export function loadConfig() {
     const result = configSchema.safeParse(process.env);

package/dist/control-handler.d.ts

@@ -0,0 +1,4 @@
+import type { ControlMessage } from './types.js';
+export type { ControlMessage };
+export declare function isControlMessage(message: unknown): message is ControlMessage;
+export declare function handleControlMessage(control: ControlMessage): Promise<void>;

package/dist/control-handler.js

@@ -0,0 +1,143 @@
+import { execSync } from 'child_process';
+import { createRequire } from 'module';
+import { logger } from './logger.js';
+import { emitEvent, flush as flushEventQueue } from './event-queue.js';
+import { doctor } from './cli/doctor.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const UPDATE_TIMEOUT_MS = 120_000; // 2 minutes
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+export function isControlMessage(message) {
+    if (typeof message !== 'object' || message === null)
+        return false;
+    const msg = message;
+    return msg['source'] === 'control' && (msg['action'] === 'restart' || msg['action'] === 'update');
+}
+export async function handleControlMessage(control) {
+    logger.info(`[Control] Received action: ${control.action}`);
+    if (control.action === 'restart') {
+        await handleRestart();
+    }
+    else if (control.action === 'update') {
+        await handleUpdate(control.targetVersion);
+    }
+}
+async function handleRestart() {
+    logger.info('[Control] Initiating graceful restart...');
+    emitEvent('poller.restart', 'system', { version: pkg.version });
+    await flushEventQueue();
+    process.exit(0);
+}
+async function handleUpdate(targetVersion) {
+    const currentVersion = pkg.version;
+    logger.info(`[Control] Starting safe update. Current version: ${currentVersion}`);
+    // Defense-in-depth: sanitize targetVersion even though resolver validates too
+    if (targetVersion && !SEMVER_RE.test(targetVersion)) {
+        logger.error(`[Control] Invalid targetVersion "${targetVersion}" — must be semver (e.g. 1.2.3)`);
+        emitEvent('poller.update.failed', 'system', { reason: 'invalid-version', currentVersion, targetVersion });
+        await flushEventQueue();
+        return;
+    }
+    // Step 1: Pre-check — verify current state is healthy
+    logger.info('[Control] Running pre-update health check...');
+    const preCheckOk = await doctor();
+    if (!preCheckOk) {
+        logger.error('[Control] Pre-update doctor check failed. Aborting update.');
+        emitEvent('poller.update.failed', 'system', {
+            reason: 'pre-check-failed',
+            currentVersion,
+        });
+        await flushEventQueue();
+        return;
+    }
+    // Step 2: Determine target version
+    // Without explicit targetVersion, find latest and only allow patch updates
+    let resolvedVersion = targetVersion;
+    if (!resolvedVersion) {
+        try {
+            resolvedVersion = execSync('npm view @teamvibe/poller version', {
+                encoding: 'utf-8',
+                timeout: 15_000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            logger.error('[Control] Failed to check npm registry for latest version');
+            emitEvent('poller.update.failed', 'system', { reason: 'registry-check-failed', currentVersion });
+            await flushEventQueue();
+            return;
+        }
+        if (!SEMVER_RE.test(resolvedVersion)) {
+            logger.error(`[Control] npm returned invalid version: "${resolvedVersion}"`);
+            return;
+        }
+        if (resolvedVersion === currentVersion) {
+            logger.info(`[Control] Already on latest version (${currentVersion})`);
+            return;
+        }
+    }
+    const packageSpec = `@teamvibe/poller@${resolvedVersion}`;
+    logger.info(`[Control] Installing ${packageSpec}...`);
+    try {
+        execSync(`npm install -g ${packageSpec}`, {
+            timeout: UPDATE_TIMEOUT_MS,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+        logger.info('[Control] npm install completed');
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`[Control] Update failed: ${errorMsg}`);
+        // Update failed — no rollback needed (original version still in place)
+        emitEvent('poller.update.failed', 'system', {
+            reason: 'install-failed',
+            currentVersion,
+            targetVersion: resolvedVersion,
+            error: errorMsg,
+        });
+        await flushEventQueue();
+        return;
+    }
+    // Step 3: Post-update doctor check
+    logger.info('[Control] Running post-update health check...');
+    const postCheckOk = await doctor();
+    if (!postCheckOk) {
+        logger.warn(`[Control] Post-update doctor failed. Rolling back to ${currentVersion}...`);
+        // Step 4: Rollback
+        try {
+            execSync(`npm install -g @teamvibe/poller@${currentVersion}`, {
+                timeout: UPDATE_TIMEOUT_MS,
+                stdio: 'pipe',
+                encoding: 'utf-8',
+            });
+            logger.info(`[Control] Rolled back to ${currentVersion}`);
+            emitEvent('poller.update.rolledback', 'system', {
+                currentVersion,
+                targetVersion: resolvedVersion,
+                reason: 'post-check-failed',
+            });
+        }
+        catch (rollbackError) {
+            const errMsg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+            logger.error(`[Control] CRITICAL: Rollback failed: ${errMsg}`);
+            emitEvent('poller.update.rollback-failed', 'system', {
+                currentVersion,
+                targetVersion: resolvedVersion,
+                error: errMsg,
+            });
+        }
+        await flushEventQueue();
+        // Restart anyway — launchd will bring us back (exit 1 to signal failure)
+        process.exit(1);
+        return;
+    }
+    // Step 5: Success — restart with new version
+    logger.info('[Control] Update successful. Restarting with new version...');
+    emitEvent('poller.update.success', 'system', {
+        previousVersion: currentVersion,
+        targetVersion: resolvedVersion,
+    });
+    await flushEventQueue();
+    process.exit(0);
+}

package/dist/control-handler.test.js

@@ -0,0 +1,74 @@
+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');
+    });
+});

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const command = process.argv[2];
-if (command && ['install', 'uninstall', 'update', 'logs', 'status', 'start', 'stop', 'restart', 'reset', '--help', '-h', '--version', '-v'].includes(command)) {
+if (command && ['install', 'uninstall', 'update', 'doctor', 'logs', 'status', 'start', 'stop', 'restart', 'reset', '--help', '-h', '--version', '-v'].includes(command)) {
     const { handleCommand } = await import('./cli/commands.js');
     await handleCommand(command);
 }