byterover-cli 0.3.5 → 0.4.1

package/dist/infra/cipher/agent-service-factory.js

@@ -2,7 +2,7 @@ import { join } from 'node:path';
 import { createBlobStorage } from './blob/blob-storage-factory.js';
 import { AgentEventBus, SessionEventBus } from './events/event-emitter.js';
 import { FileSystemService } from './file-system/file-system-service.js';
-import { ByteRoverLlmGrpcService } from './grpc/internal-llm-grpc-service.js';
+import { ByteRoverLlmHttpService } from './http/internal-llm-http-service.js';
 import { ByteRoverContentGenerator, LoggingContentGenerator, RetryableContentGenerator } from './llm/generators/index.js';
 import { ByteRoverLLMService } from './llm/internal-llm-service.js';
 import { OpenRouterLLMService } from './llm/openrouter-llm-service.js';
@@ -11,6 +11,10 @@ import { EventBasedLogger } from './logger/event-based-logger.js';
 import { MemoryManager } from './memory/memory-manager.js';
 import { ProcessService } from './process/process-service.js';
 import { BlobHistoryStorage } from './storage/blob-history-storage.js';
+import { DualFormatHistoryStorage } from './storage/dual-format-history-storage.js';
+import { GranularHistoryStorage } from './storage/granular-history-storage.js';
+import { MessageStorageService } from './storage/message-storage-service.js';
+import { SqliteKeyStorage } from './storage/sqlite-key-storage.js';
 import { SimplePromptFactory } from './system-prompt/simple-prompt-factory.js';
 import { CoreToolScheduler } from './tools/core-tool-scheduler.js';
 import { DEFAULT_POLICY_RULES } from './tools/default-policy-rules.js';
@@ -82,7 +86,27 @@ export async function createCipherAgentServices(llmConfig) {
     const toolManager = new ToolManager(toolProvider, toolScheduler);
     await toolManager.initialize();
     // 11. History storage (depends on BlobStorage) - SHARED across sessions
-    const historyStorage = new BlobHistoryStorage(blobStorage);
+    // Use DualFormatHistoryStorage when granular storage is enabled
+    let historyStorage;
+    if (llmConfig.useGranularStorage) {
+        // Create granular storage infrastructure
+        const keyStorage = new SqliteKeyStorage({
+            storageDir: join(workingDirectory, '.brv'),
+        });
+        await keyStorage.initialize();
+        const messageStorage = new MessageStorageService(keyStorage);
+        const granularStorage = new GranularHistoryStorage(messageStorage);
+        const blobHistoryStorage = new BlobHistoryStorage(blobStorage);
+        // DualFormatHistoryStorage routes between formats:
+        // - New sessions → GranularHistoryStorage
+        // - Existing sessions → BlobHistoryStorage (no migration)
+        historyStorage = new DualFormatHistoryStorage(blobHistoryStorage, granularStorage);
+        logger.info('Granular history storage enabled for new sessions');
+    }
+    else {
+        // Default: use blob storage for all sessions
+        historyStorage = new BlobHistoryStorage(blobStorage);
+    }
     // Log successful initialization
     logger.info('CipherAgent services initialized successfully', {
         model: llmConfig.model,
@@ -116,7 +140,7 @@ export async function createCipherAgentServices(llmConfig) {
  *
  * @param sessionId - Unique session identifier
  * @param sharedServices - Shared services from agent
- * @param grpcConfig - gRPC configuration
+ * @param httpConfig - HTTP configuration
  * @param llmConfig - LLM service configuration
  * @param llmConfig.openRouterApiKey - Optional OpenRouter API key for OpenRouter service
  * @param llmConfig.httpReferer - Optional HTTP Referer for OpenRouter rankings
@@ -128,7 +152,7 @@ export async function createCipherAgentServices(llmConfig) {
  * @param llmConfig.verbose - Enable verbose debug output
  * @returns Initialized session services
  */
-export function createSessionServices(sessionId, sharedServices, grpcConfig, llmConfig) {
+export function createSessionServices(sessionId, sharedServices, httpConfig, llmConfig) {
     // 1. Create session-specific event bus
     const sessionEventBus = new SessionEventBus();
     // 2. Create session-scoped logger
@@ -157,20 +181,20 @@ export function createSessionServices(sessionId, sharedServices, grpcConfig, llm
         });
     }
     else {
-        // Use gRPC backend service (default) with new generator pattern
-        // Step 1: Create gRPC service
-        const grpcService = new ByteRoverLlmGrpcService({
-            accessToken: grpcConfig.accessToken,
-            grpcEndpoint: grpcConfig.grpcEndpoint,
-            projectId: grpcConfig.projectId,
-            region: grpcConfig.region,
-            sessionKey: grpcConfig.sessionKey,
-            spaceId: grpcConfig.spaceId,
-            teamId: grpcConfig.teamId,
-            timeout: grpcConfig.timeout,
+        // Use HTTP backend service (default) with new generator pattern
+        // Step 1: Create HTTP service
+        const httpService = new ByteRoverLlmHttpService({
+            accessToken: httpConfig.accessToken,
+            apiBaseUrl: httpConfig.apiBaseUrl,
+            projectId: httpConfig.projectId,
+            region: httpConfig.region,
+            sessionKey: httpConfig.sessionKey,
+            spaceId: httpConfig.spaceId,
+            teamId: httpConfig.teamId,
+            timeout: httpConfig.timeout,
         });
         // Step 2: Create base content generator
-        let generator = new ByteRoverContentGenerator(grpcService, {
+        let generator = new ByteRoverContentGenerator(httpService, {
             maxTokens: llmConfig.maxTokens ?? 8192,
             model: llmConfig.model ?? 'gemini-2.5-pro',
             temperature: llmConfig.temperature ?? 0.7,

package/dist/infra/cipher/cipher-agent.js

@@ -209,10 +209,10 @@ export class CipherAgent {
         // No need for upfront validation - let services handle their own setup
         // Create SHARED services only (following Dexto's pattern)
         const sharedServices = await createCipherAgentServices(this.llmConfig);
-        // Extract gRPC config from llmConfig
-        const grpcConfig = {
+        // Extract HTTP config from llmConfig
+        const httpConfig = {
             accessToken: this.llmConfig.accessToken,
-            grpcEndpoint: this.llmConfig.grpcEndpoint,
+            apiBaseUrl: this.llmConfig.apiBaseUrl,
             projectId: this.llmConfig.projectId,
             region: this.llmConfig.region,
             sessionKey: this.llmConfig.sessionKey,
@@ -231,7 +231,7 @@ export class CipherAgent {
             verbose: this.llmConfig.verbose,
         };
         // Create SessionManager with shared services
-        const sessionManager = new SessionManager(sharedServices, grpcConfig, sessionLLMConfig, {
+        const sessionManager = new SessionManager(sharedServices, httpConfig, sessionLLMConfig, {
             config: {
                 maxSessions: 100,
                 sessionTTL: 3_600_000, // 1 hour

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;