byterover-cli 0.3.4 → 0.4.0

package/dist/infra/cipher/consumer/consumer-lock.d.ts

@@ -0,0 +1,20 @@
+/**
+ * DB-based consumer lock utilities
+ *
+ * The actual locking is now handled by AgentStorage methods:
+ * - acquireConsumerLock(consumerId)
+ * - releaseConsumerLock(consumerId)
+ * - hasActiveConsumer(timeoutMs)
+ *
+ * These utility functions provide a simple interface for checking consumer status.
+ */
+/**
+ * Check if a consumer is currently running (has active heartbeat in DB)
+ * Auto-detects .brv/blobs path from cwd
+ */
+export declare function isConsumerRunning(): Promise<boolean>;
+/**
+ * Check if a consumer is currently running (sync version)
+ * Assumes storage is already initialized
+ */
+export declare function isConsumerRunningSync(): boolean;

package/dist/infra/cipher/consumer/consumer-lock.js

@@ -0,0 +1,40 @@
+import { getAgentStorage, getAgentStorageSync } from '../storage/agent-storage.js';
+// Consumer is considered stale after 30 seconds without heartbeat
+const STALE_TIMEOUT_MS = 30_000;
+/**
+ * DB-based consumer lock utilities
+ *
+ * The actual locking is now handled by AgentStorage methods:
+ * - acquireConsumerLock(consumerId)
+ * - releaseConsumerLock(consumerId)
+ * - hasActiveConsumer(timeoutMs)
+ *
+ * These utility functions provide a simple interface for checking consumer status.
+ */
+/**
+ * Check if a consumer is currently running (has active heartbeat in DB)
+ * Auto-detects .brv/blobs path from cwd
+ */
+export async function isConsumerRunning() {
+    try {
+        const storage = await getAgentStorage();
+        return storage.hasActiveConsumer(STALE_TIMEOUT_MS);
+    }
+    catch {
+        // If we can't check, assume not running
+        return false;
+    }
+}
+/**
+ * Check if a consumer is currently running (sync version)
+ * Assumes storage is already initialized
+ */
+export function isConsumerRunningSync() {
+    try {
+        const storage = getAgentStorageSync();
+        return storage.hasActiveConsumer(STALE_TIMEOUT_MS);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/infra/cipher/consumer/consumer-service.d.ts

@@ -0,0 +1,99 @@
+export interface ConsumerServiceOptions {
+    /** Max concurrent jobs (default: 5) */
+    concurrency?: number;
+    /** Poll interval in ms (default: 1000) */
+    pollInterval?: number;
+}
+/**
+ * ConsumerService - Singleton background worker that processes the execution queue
+ *
+ * Architecture:
+ * ```
+ * ┌─────────────────┐
+ * │ ConsumerService │  ← Singleton, start once in main
+ * │ (process jobs)  │
+ * └────────┬────────┘
+ *          │ writes
+ *          ▼
+ * ┌─────────────────┐
+ * │  AgentStorage   │  ← SQLite DB (source of truth)
+ * │   (agent.db)    │
+ * └────────┬────────┘
+ *          │ polls
+ *          ▼
+ * ┌─────────────────┐
+ * │QueuePollingServ │  ← UI subscribes here for updates
+ * └─────────────────┘
+ * ```
+ *
+ * Usage:
+ * ```typescript
+ * // Main - start consumer singleton (once)
+ * const consumer = getConsumerService({ concurrency: 5 })
+ * await consumer.start()
+ *
+ * // UI components - use QueuePollingService for monitoring
+ * import { getQueuePollingService } from './queue-polling-service'
+ * const poller = getQueuePollingService({ pollInterval: 500 })
+ * poller.on('snapshot', (snapshot) => renderUI(snapshot))
+ * await poller.start()
+ *
+ * // Cleanup
+ * consumer.dispose()
+ * ```
+ *
+ * Features:
+ * - Auto-loads auth token from Keychain
+ * - Auto-loads project config from .brv/config.json
+ * - Handles lock acquisition/release
+ * - Single dispose() for full cleanup
+ */
+export declare class ConsumerService {
+    private consumer;
+    private readonly options;
+    private running;
+    constructor(options?: ConsumerServiceOptions);
+    /**
+     * Stop the consumer and cleanup all resources
+     */
+    dispose(): void;
+    /**
+     * Get the consumer ID (unique per session)
+     * Returns null if consumer hasn't started yet
+     */
+    getConsumerId(): null | string;
+    /**
+     * Check if consumer is running
+     */
+    isRunning(): boolean;
+    /**
+     * Start the consumer
+     *
+     * - Loads auth token from Keychain
+     * - Loads project config from .brv/config.json
+     * - Acquires consumer lock
+     * - Starts processing queue
+     *
+     * @throws Error if not authenticated
+     * @throws Error if another consumer is already running
+     */
+    start(): Promise<void>;
+    stop(): void;
+    private setupSignalHandlers;
+}
+/**
+ * Get or create singleton ConsumerService
+ *
+ * Usage:
+ * ```typescript
+ * const consumer = getConsumerService()
+ * await consumer.start()
+ * // later...
+ * consumer.dispose()
+ * ```
+ */
+export declare function getConsumerService(options?: ConsumerServiceOptions): ConsumerService;
+/**
+ * Dispose singleton and clear reference
+ */
+export declare function disposeConsumerService(): void;

package/dist/infra/cipher/consumer/consumer-service.js

@@ -0,0 +1,165 @@
+import { ProjectConfigStore } from '../../config/file-config-store.js';
+import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
+import { closeAgentStorage } from '../storage/agent-storage.js';
+import { createExecutionConsumer } from './execution-consumer.js';
+// ==================== SERVICE ====================
+/**
+ * ConsumerService - Singleton background worker that processes the execution queue
+ *
+ * Architecture:
+ * ```
+ * ┌─────────────────┐
+ * │ ConsumerService │  ← Singleton, start once in main
+ * │ (process jobs)  │
+ * └────────┬────────┘
+ *          │ writes
+ *          ▼
+ * ┌─────────────────┐
+ * │  AgentStorage   │  ← SQLite DB (source of truth)
+ * │   (agent.db)    │
+ * └────────┬────────┘
+ *          │ polls
+ *          ▼
+ * ┌─────────────────┐
+ * │QueuePollingServ │  ← UI subscribes here for updates
+ * └─────────────────┘
+ * ```
+ *
+ * Usage:
+ * ```typescript
+ * // Main - start consumer singleton (once)
+ * const consumer = getConsumerService({ concurrency: 5 })
+ * await consumer.start()
+ *
+ * // UI components - use QueuePollingService for monitoring
+ * import { getQueuePollingService } from './queue-polling-service'
+ * const poller = getQueuePollingService({ pollInterval: 500 })
+ * poller.on('snapshot', (snapshot) => renderUI(snapshot))
+ * await poller.start()
+ *
+ * // Cleanup
+ * consumer.dispose()
+ * ```
+ *
+ * Features:
+ * - Auto-loads auth token from Keychain
+ * - Auto-loads project config from .brv/config.json
+ * - Handles lock acquisition/release
+ * - Single dispose() for full cleanup
+ */
+export class ConsumerService {
+    consumer = null;
+    options;
+    running = false;
+    constructor(options) {
+        this.options = options ?? {};
+    }
+    /**
+     * Stop the consumer and cleanup all resources
+     */
+    dispose() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.consumer) {
+            this.consumer.stop();
+            this.consumer = null;
+        }
+        closeAgentStorage();
+    }
+    /**
+     * Get the consumer ID (unique per session)
+     * Returns null if consumer hasn't started yet
+     */
+    getConsumerId() {
+        return this.consumer?.getConsumerId() ?? null;
+    }
+    /**
+     * Check if consumer is running
+     */
+    isRunning() {
+        return this.running && this.consumer !== null;
+    }
+    /**
+     * Start the consumer
+     *
+     * - Loads auth token from Keychain
+     * - Loads project config from .brv/config.json
+     * - Acquires consumer lock
+     * - Starts processing queue
+     *
+     * @throws Error if not authenticated
+     * @throws Error if another consumer is already running
+     */
+    async start() {
+        if (this.running) {
+            throw new Error('Consumer already running');
+        }
+        // Load auth token
+        const tokenStore = new KeychainTokenStore();
+        const token = await tokenStore.load();
+        if (!token) {
+            throw new Error('Not authenticated. Please run "brv login" first.');
+        }
+        // Load project config (optional)
+        const configStore = new ProjectConfigStore();
+        const brvConfig = await configStore.read();
+        // Create consumer (auto-detects .brv/blobs from cwd)
+        this.consumer = createExecutionConsumer({
+            authToken: { accessToken: token.accessToken, sessionKey: token.sessionKey },
+            brvConfig: brvConfig ?? undefined,
+            maxConcurrency: this.options.concurrency ?? 5,
+            pollInterval: this.options.pollInterval ?? 1000,
+        });
+        // Start consumer
+        const started = await this.consumer.start();
+        if (!started) {
+            this.consumer = null;
+            throw new Error('Another consumer is already running in this directory');
+        }
+        this.running = true;
+        this.setupSignalHandlers();
+    }
+    // Alias for dispose
+    stop() {
+        this.dispose();
+    }
+    // ==================== PRIVATE ====================
+    setupSignalHandlers() {
+        // eslint-disable-next-line unicorn/consistent-function-scoping -- needs 'this' context
+        const cleanup = () => {
+            this.dispose();
+        };
+        process.on('SIGTERM', cleanup);
+        process.on('SIGINT', cleanup);
+        process.on('exit', cleanup);
+    }
+}
+// ==================== SINGLETON HELPER ====================
+let instance = null;
+/**
+ * Get or create singleton ConsumerService
+ *
+ * Usage:
+ * ```typescript
+ * const consumer = getConsumerService()
+ * await consumer.start()
+ * // later...
+ * consumer.dispose()
+ * ```
+ */
+export function getConsumerService(options) {
+    if (!instance) {
+        instance = new ConsumerService(options);
+    }
+    return instance;
+}
+/**
+ * Dispose singleton and clear reference
+ */
+export function disposeConsumerService() {
+    if (instance) {
+        instance.dispose();
+        instance = null;
+    }
+}

package/dist/infra/cipher/consumer/execution-consumer.d.ts

@@ -0,0 +1,121 @@
+import type { BrvConfig } from '../../../core/domain/entities/brv-config.js';
+/**
+ * ExecutionConsumer - Polls queue and executes jobs in parallel
+ *
+ * Features:
+ * - DB-based lock with heartbeat (detects dead consumers)
+ * - Poll loop every 1 second
+ * - Parallel processing with configurable concurrency (default 5)
+ * - Process curate executions
+ * - Track tool calls to database
+ * - Cleanup old executions periodically
+ */
+export declare class ExecutionConsumer {
+    private readonly activeJobs;
+    private authToken?;
+    private readonly brvConfig?;
+    private readonly consumerId;
+    private heartbeatInterval?;
+    private readonly maxConcurrency;
+    private readonly pollInterval;
+    private running;
+    constructor(options?: {
+        authToken?: {
+            accessToken: string;
+            sessionKey: string;
+        };
+        brvConfig?: BrvConfig;
+        maxConcurrency?: number;
+        pollInterval?: number;
+    });
+    /**
+     * Get the unique consumer ID for this instance
+     */
+    getConsumerId(): string;
+    /**
+     * Check if consumer is running
+     */
+    isRunning(): boolean;
+    /**
+     * Set auth token (can be set after construction)
+     */
+    setAuthToken(token: {
+        accessToken: string;
+        sessionKey: string;
+    }): void;
+    /**
+     * Start the consumer
+     * @returns true if started successfully, false if another consumer is running
+     */
+    start(): Promise<boolean>;
+    /**
+     * Stop the consumer
+     * Idempotent - safe to call multiple times (only runs cleanup once)
+     */
+    stop(): void;
+    /**
+     * Execute a curate job
+     */
+    private executeCurate;
+    /**
+     * Log execution start (extracted to reduce nesting depth)
+     */
+    private logExecutionStart;
+    /**
+     * Main poll loop - dequeues and processes jobs in parallel up to maxConcurrency
+     */
+    private poll;
+    /**
+     * Process a single execution
+     */
+    private processExecution;
+    /**
+     * Process execution asynchronously (fire and forget with tracking)
+     */
+    private processExecutionAsync;
+    /**
+     * Setup tool call tracking via event listeners
+     */
+    private setupToolCallTracking;
+    /**
+     * Try to pick up queued jobs (called after job completion)
+     */
+    private tryPickupJobs;
+    /**
+     * Try to recover lock after error (extracted to reduce nesting depth)
+     */
+    private tryRecoverLock;
+}
+/**
+ * Create a new ExecutionConsumer instance
+ */
+export declare function createExecutionConsumer(options?: {
+    authToken?: {
+        accessToken: string;
+        sessionKey: string;
+    };
+    brvConfig?: BrvConfig;
+    maxConcurrency?: number;
+    pollInterval?: number;
+}): ExecutionConsumer;
+/**
+ * Try to start a consumer (singleton pattern)
+ * Returns the consumer instance if started, null if already running
+ */
+export declare function tryStartConsumer(options?: {
+    authToken?: {
+        accessToken: string;
+        sessionKey: string;
+    };
+    brvConfig?: BrvConfig;
+    maxConcurrency?: number;
+    pollInterval?: number;
+}): Promise<ExecutionConsumer | null>;
+/**
+ * Get the current consumer instance (if running)
+ */
+export declare function getConsumer(): ExecutionConsumer | null;
+/**
+ * Stop the current consumer
+ */
+export declare function stopConsumer(): void;