byterover-cli 0.3.5 → 0.4.0

package/dist/infra/cipher/session/session-manager.d.ts

@@ -1,6 +1,6 @@
 import type { CipherAgentServices, SessionManagerConfig } from '../../../core/interfaces/cipher/cipher-services.js';
 import type { IChatSession } from '../../../core/interfaces/cipher/i-chat-session.js';
-import type { ByteRoverGrpcConfig } from '../agent-service-factory.js';
+import type { ByteRoverHttpConfig } from '../agent-service-factory.js';
 /**
  * Options for SessionManager constructor
  */
@@ -18,7 +18,7 @@ export interface SessionManagerOptions {
  */
 export declare class SessionManager {
     private readonly config;
-    private readonly grpcConfig;
+    private readonly httpConfig;
     private readonly llmConfig;
     private pendingCreations;
     private readonly sessions;
@@ -27,7 +27,7 @@ export declare class SessionManager {
      * Creates a new session manager
      *
      * @param sharedServices - Shared services from CipherAgent (ToolManager, SystemPromptManager, etc.)
-     * @param grpcConfig - gRPC client configuration
+     * @param httpConfig - HTTP client configuration
      * @param llmConfig - LLM service configuration
      * @param llmConfig.openRouterApiKey - Optional OpenRouter API key for direct service
      * @param llmConfig.httpReferer - Optional HTTP Referer for OpenRouter rankings
@@ -39,7 +39,7 @@ export declare class SessionManager {
      * @param options - Optional session manager options
      * @param options.config - Session manager configuration
      */
-    constructor(sharedServices: CipherAgentServices, grpcConfig: ByteRoverGrpcConfig, llmConfig: {
+    constructor(sharedServices: CipherAgentServices, httpConfig: ByteRoverHttpConfig, llmConfig: {
         httpReferer?: string;
         maxIterations?: number;
         maxTokens?: number;

package/dist/infra/cipher/session/session-manager.js

@@ -12,7 +12,7 @@ import { ChatSession } from './chat-session.js';
  */
 export class SessionManager {
     config;
-    grpcConfig;
+    httpConfig;
     llmConfig;
     pendingCreations = new Map();
     sessions = new Map();
@@ -21,7 +21,7 @@ export class SessionManager {
      * Creates a new session manager
      *
      * @param sharedServices - Shared services from CipherAgent (ToolManager, SystemPromptManager, etc.)
-     * @param grpcConfig - gRPC client configuration
+     * @param httpConfig - HTTP client configuration
      * @param llmConfig - LLM service configuration
      * @param llmConfig.openRouterApiKey - Optional OpenRouter API key for direct service
      * @param llmConfig.httpReferer - Optional HTTP Referer for OpenRouter rankings
@@ -33,9 +33,9 @@ export class SessionManager {
      * @param options - Optional session manager options
      * @param options.config - Session manager configuration
      */
-    constructor(sharedServices, grpcConfig, llmConfig, options) {
+    constructor(sharedServices, httpConfig, llmConfig, options) {
         this.sharedServices = sharedServices;
-        this.grpcConfig = grpcConfig;
+        this.httpConfig = httpConfig;
         this.llmConfig = llmConfig;
         this.config = {
             maxSessions: options?.config?.maxSessions ?? 100,
@@ -157,7 +157,7 @@ export class SessionManager {
      */
     async createSessionInternal(id) {
         // Create session-specific services using factory
-        const sessionServices = createSessionServices(id, this.sharedServices, this.grpcConfig, this.llmConfig);
+        const sessionServices = createSessionServices(id, this.sharedServices, this.httpConfig, this.llmConfig);
         // Create session with both shared and session services
         const session = new ChatSession(id, this.sharedServices, sessionServices);
         // Initialize LLM service to load persisted history from blob storage

package/dist/infra/cipher/storage/agent-storage.d.ts

@@ -0,0 +1,246 @@
+import type { Execution, ExecutionStatus, ExecutionType, ToolCall, ToolCallInfo, ToolCallStatus, ToolCallUpdateOptions } from '../../../core/domain/cipher/queue/types.js';
+import type { IAgentStorage } from '../../../core/interfaces/cipher/i-agent-storage.js';
+export type { ConsumerLock, Execution, ExecutionStatus, ExecutionType, ToolCall, ToolCallInfo, ToolCallStatus, ToolCallUpdateOptions, } from '../../../core/domain/cipher/queue/types.js';
+/**
+ * AgentStorage - SQLite-based storage for execution queue and tool calls
+ *
+ * Features:
+ * - Single database file at .brv/blobs/agent.db
+ * - Job queue via executions.status = 'queued'
+ * - Tool call tracking for UI polling
+ * - Prepared statement caching (no memory leak)
+ * - WAL mode for concurrent read/write
+ * - Orphan cleanup on startup
+ * - Old execution cleanup (max 100)
+ */
+export declare class AgentStorage implements IAgentStorage {
+    initialized: boolean;
+    private db;
+    private dbFileInode;
+    private readonly dbPath;
+    private readonly inMemory;
+    private stmtAddToolCall;
+    private stmtCleanupOrphans;
+    private stmtCountCompletedFailed;
+    private stmtCreateExecution;
+    private stmtDeleteConsumerLock;
+    private stmtDeleteOldExecutions;
+    private stmtDequeueBatchSelect;
+    private stmtDequeueSelect;
+    private stmtFailQuery;
+    private stmtGetExecution;
+    private stmtGetExecutionsSince;
+    private stmtGetQueuedExecutions;
+    private stmtGetRecentExecutions;
+    private stmtGetRunningExecutions;
+    private stmtGetToolCalls;
+    private stmtOrphanFromConsumer;
+    private stmtOrphanMissingConsumer;
+    private stmtOrphanNullConsumer;
+    private stmtUpdateStatus;
+    private stmtUpdateToolCall;
+    private readonly storageDir;
+    constructor(config?: {
+        inMemory?: boolean;
+        storageDir?: string;
+    });
+    /**
+     * Acquire consumer lock (register this consumer)
+     * Only ONE consumer can run at a time - checks for any active consumer first
+     * @returns true if lock acquired, false if another consumer is already running
+     */
+    acquireConsumerLock(consumerId: string): boolean;
+    /**
+     * Add a tool call record
+     * @returns tool call id
+     */
+    addToolCall(executionId: string, info: ToolCallInfo): string;
+    /**
+     * Cleanup old executions, keep only maxKeep most recent completed/failed
+     */
+    cleanupOldExecutions(maxKeep?: number): number;
+    /**
+     * Cleanup orphaned executions (status='running') from previous session crash
+     * Should be called on startup
+     */
+    cleanupOrphanedExecutions(): number;
+    /**
+     * Cleanup stale consumers and orphan their executions
+     * A consumer is stale if its heartbeat is older than timeoutMs
+     * @param timeoutMs - heartbeat timeout (default 30 seconds)
+     * @returns number of orphaned executions
+     */
+    cleanupStaleConsumers(timeoutMs?: number): number;
+    /**
+     * Close database connection
+     */
+    close(): void;
+    /**
+     * Create a new execution
+     * @param type - 'curate' or 'query'
+     * @param input - content (curate) or query string (query)
+     * @returns execution id
+     */
+    createExecution(type: ExecutionType, input: string): string;
+    /**
+     * Dequeue multiple executions at once (atomic batch SELECT + UPDATE)
+     * This is more efficient than calling dequeueExecution() multiple times
+     * and ensures all queued items are seen in a single transaction snapshot
+     * @param limit - max number of executions to dequeue
+     * @param consumerId - ID of the consumer claiming these executions
+     * @returns array of executions (may be empty if queue is empty)
+     */
+    dequeueBatch(limit: number, consumerId?: string): Execution[];
+    /**
+     * Dequeue next queued execution (atomic SELECT + UPDATE)
+     * @param consumerId - ID of the consumer claiming this execution
+     * @returns execution or null if queue is empty
+     */
+    dequeueExecution(consumerId?: string): Execution | null;
+    /**
+     * Get execution by id
+     */
+    getExecution(id: string): Execution | null;
+    /**
+     * Get executions updated since timestamp (for incremental polling)
+     */
+    getExecutionsSince(timestamp: number): Execution[];
+    /**
+     * Get execution with all its tool calls (for UI display)
+     */
+    getExecutionWithToolCalls(id: string): null | {
+        execution: Execution;
+        toolCalls: ToolCall[];
+    };
+    /**
+     * Get all queued executions
+     */
+    getQueuedExecutions(): Execution[];
+    /**
+     * Get recent executions (for UI display)
+     */
+    getRecentExecutions(limit?: number): Execution[];
+    /**
+     * Get all running executions
+     */
+    getRunningExecutions(): Execution[];
+    /**
+     * Get all executions belonging to a specific consumer session.
+     * Returns executions ordered by created_at ASC (oldest first, newest last).
+     * Includes:
+     * - Curate executions with matching consumer_id
+     * - Query executions created after consumer started (no consumer_id)
+     */
+    getSessionExecutions(consumerId: string): Execution[];
+    /**
+     * Get queue statistics (queries DB directly for accurate counts)
+     */
+    getStats(): {
+        completed: number;
+        failed: number;
+        queued: number;
+        running: number;
+        total: number;
+    };
+    /**
+     * Get all tool calls for an execution
+     */
+    getToolCalls(executionId: string): ToolCall[];
+    /**
+     * Check if any consumer is currently active (has recent heartbeat)
+     * @param timeoutMs - heartbeat timeout (default 30 seconds)
+     */
+    hasActiveConsumer(timeoutMs?: number): boolean;
+    /**
+     * Check if a specific consumer lock exists in the database
+     * Used by Consumer to verify its lock is still valid after DB reconnection
+     */
+    hasConsumerLock(consumerId: string): boolean;
+    /**
+     * Initialize storage - create tables, enable WAL
+     * @param options - Initialization options
+     * @param options.cleanupOrphans - If true, cleanup orphaned executions (only Consumer should set this)
+     */
+    initialize(options?: {
+        cleanupOrphans?: boolean;
+    }): Promise<void>;
+    /**
+     * Check if the DB file has been replaced (different inode)
+     * Returns true if DB needs reconnection
+     */
+    isDbFileChanged(): boolean;
+    /**
+     * Reconnect to the database (close and reinitialize)
+     * Use when DB file has been replaced by another process (e.g., brv init)
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Release consumer lock (unregister this consumer)
+     */
+    releaseConsumerLock(consumerId: string): void;
+    /**
+     * Update consumer heartbeat
+     */
+    updateConsumerHeartbeat(consumerId: string): void;
+    /**
+     * Update execution status
+     */
+    updateExecutionStatus(id: string, status: ExecutionStatus, result?: string, error?: string): void;
+    /**
+     * Update tool call status and result
+     */
+    updateToolCall(id: string, status: ToolCallStatus, options?: ToolCallUpdateOptions): void;
+    /**
+     * Ensure storage has been initialized
+     */
+    private ensureInitialized;
+    /**
+     * Get database instance with type safety (throws if not initialized)
+     * Use this instead of this.getDb() for proper type narrowing
+     */
+    private getDb;
+    /**
+     * Convert database row to Execution object
+     */
+    private rowToExecution;
+    /**
+     * Convert database row to ToolCall object
+     */
+    private rowToToolCall;
+}
+/**
+ * Get the singleton AgentStorage instance (auto-initializes if needed)
+ *
+ * This is the PRIMARY API - just call this and it handles everything.
+ * First call will initialize with provided config, subsequent calls return cached instance.
+ *
+ * @param config - Configuration options
+ * @param config.cleanupOrphans - Cleanup orphaned executions (only Consumer should set this)
+ * @param config.inMemory - Use in-memory database (for testing)
+ * @param config.storageDir - Directory for agent.db (default: .brv/blobs)
+ */
+export declare function getAgentStorage(config?: {
+    cleanupOrphans?: boolean;
+    inMemory?: boolean;
+    storageDir?: string;
+}): Promise<AgentStorage>;
+/**
+ * Get the singleton AgentStorage instance (sync version)
+ * THROWS if not initialized - use getAgentStorage() instead for auto-init
+ *
+ * Use this only when you KNOW storage is already initialized (e.g., in Consumer after start)
+ */
+export declare function getAgentStorageSync(): AgentStorage;
+/**
+ * Initialize the singleton AgentStorage instance
+ * @deprecated Use getAgentStorage() directly - it auto-initializes
+ */
+export declare function initializeAgentStorage(config?: {
+    cleanupOrphans?: boolean;
+    inMemory?: boolean;
+    storageDir?: string;
+}): Promise<AgentStorage>;
+/**
+ * Close and clear the singleton AgentStorage instance
+ */
+export declare function closeAgentStorage(): void;