byterover-cli 1.5.0 → 1.6.0

package/dist/infra/process/inline-agent-executor.js

@@ -0,0 +1,259 @@
+/**
+ * InlineAgent - Ephemeral in-process CipherAgent for headless commands.
+ *
+ * Used by `brv curate --headless` and `brv query --headless` to execute tasks
+ * without requiring a running REPL instance or Transport/Socket.IO infrastructure.
+ *
+ * Exposes a `transportClient` property (ITransportClient) so use cases can use it
+ * as a drop-in replacement for SocketIOTransportClient.
+ *
+ * Lifecycle:
+ * 1. InlineAgent.create() — loads auth, config, starts CipherAgent
+ * 2. Use case gets inlineAgent.transportClient and calls on()/request() as normal
+ * 3. transportClient.disconnect() — stops CipherAgent and cleans up
+ */
+import { randomUUID } from 'node:crypto';
+import { getCurrentConfig } from '../../config/environment.js';
+import { DEFAULT_LLM_MODEL, PROJECT } from '../../constants.js';
+import { NotAuthenticatedError, serializeTaskError } from '../../core/domain/errors/task-error.js';
+import { CipherAgent } from '../cipher/agent/index.js';
+import { ProjectConfigStore } from '../config/file-config-store.js';
+import { CurateExecutor } from '../core/executors/curate-executor.js';
+import { QueryExecutor } from '../core/executors/query-executor.js';
+import { createTokenStore } from '../storage/token-store.js';
+/**
+ * Ephemeral in-process CipherAgent for headless CLI commands.
+ *
+ * Creates and owns a CipherAgent, and exposes an ITransportClient that
+ * use cases interact with exactly like a SocketIOTransportClient.
+ */
+export class InlineAgent {
+    transportClient;
+    constructor(agent) {
+        this.transportClient = new InlineTransportClient(agent);
+    }
+    /**
+     * Async factory — loads auth/config, creates and starts CipherAgent.
+     *
+     * @throws NotAuthenticatedError if no auth token or token is expired
+     * @throws Error if no project config (.brv/config.json) exists
+     */
+    static async create() {
+        const tokenStore = createTokenStore();
+        const configStore = new ProjectConfigStore();
+        const authToken = await tokenStore.load();
+        if (!authToken || authToken.isExpired()) {
+            throw new NotAuthenticatedError();
+        }
+        const brvConfig = await configStore.read();
+        if (!brvConfig) {
+            throw new Error('Project not initialized. Run `brv` then `/init` first.');
+        }
+        const envConfig = getCurrentConfig();
+        const agentConfig = {
+            accessToken: authToken.accessToken,
+            apiBaseUrl: envConfig.llmApiBaseUrl,
+            fileSystem: { workingDirectory: process.cwd() },
+            llm: {
+                maxIterations: 10,
+                maxTokens: 4096,
+                temperature: 0.7,
+                topK: 10,
+                topP: 0.95,
+                verbose: false,
+            },
+            model: DEFAULT_LLM_MODEL,
+            projectId: PROJECT,
+            sessionKey: authToken.sessionKey,
+        };
+        const agent = new CipherAgent(agentConfig, brvConfig);
+        await agent.start();
+        const sessionId = `inline-session-${randomUUID()}`;
+        await agent.createSession(sessionId);
+        return new InlineAgent(agent);
+    }
+}
+/**
+ * ITransportClient backed by an in-process CipherAgent.
+ *
+ * Translates transport events (task:create, task:completed, llmservice:*) into
+ * direct CipherAgent execution via CurateExecutor/QueryExecutor.
+ */
+class InlineTransportClient {
+    activeTask;
+    agent;
+    clientId = `inline-${randomUUID()}`;
+    curateExecutor;
+    handlers = new Map();
+    queryExecutor;
+    constructor(agent) {
+        this.agent = agent;
+        this.curateExecutor = new CurateExecutor();
+        this.queryExecutor = new QueryExecutor();
+    }
+    // ===========================================================================
+    // ITransportClient implementation
+    // ===========================================================================
+    async connect() {
+        // No-op — initialization done in InlineAgent.create()
+    }
+    async disconnect() {
+        this.handlers.clear();
+        // Stop the agent first — this causes any in-flight execute() to fail,
+        // which settles the activeTask promise.
+        try {
+            await this.agent.stop();
+        }
+        catch {
+            // Best-effort cleanup
+        }
+        // Wait for the task to settle (will resolve/reject quickly after agent.stop())
+        if (this.activeTask) {
+            await this.activeTask;
+            this.activeTask = undefined;
+        }
+    }
+    getClientId() {
+        return this.clientId;
+    }
+    getState() {
+        return 'connected';
+    }
+    async isConnected() {
+        return true;
+    }
+    async joinRoom() {
+        // No-op
+    }
+    async leaveRoom() {
+        // No-op
+    }
+    on(event, handler) {
+        if (!this.handlers.has(event)) {
+            this.handlers.set(event, new Set());
+        }
+        const handlerSet = this.handlers.get(event);
+        handlerSet.add(handler);
+        return () => {
+            handlerSet.delete(handler);
+        };
+    }
+    once(event, handler) {
+        const unsubscribe = this.on(event, (data) => {
+            unsubscribe();
+            handler(data);
+        });
+    }
+    onStateChange(_handler) {
+        // No-op — state never changes
+        return () => { };
+    }
+    async request(event, data, _options) {
+        if (event === 'task:create') {
+            // Returns immediately with {taskId}; execution runs asynchronously
+            return this.handleTaskCreate(data);
+        }
+        // Other events are no-ops for inline execution
+        return undefined;
+    }
+    // ===========================================================================
+    // Internal task execution
+    // ===========================================================================
+    /**
+     * Emit an event to all registered handlers.
+     */
+    emit(event, data) {
+        const handlerSet = this.handlers.get(event);
+        if (handlerSet) {
+            for (const handler of handlerSet) {
+                handler(data);
+            }
+        }
+    }
+    /**
+     * Execute the task in-process, emitting transport-shaped events as it progresses.
+     */
+    async executeTask(data) {
+        const taskId = data.taskId;
+        const type = data.type;
+        const content = data.content;
+        const files = data.files;
+        const clientCwd = data.clientCwd;
+        // Emit task:ack
+        this.emit('task:ack', { taskId });
+        // Emit task:started
+        this.emit('task:started', { taskId });
+        // Subscribe to agentEventBus and forward events to registered handlers
+        const cleanupForwarders = this.setupEventForwarding(taskId);
+        try {
+            const result = await (type === 'curate'
+                ? this.curateExecutor.executeWithAgent(this.agent, {
+                    clientCwd,
+                    content,
+                    files,
+                    taskId,
+                })
+                : this.queryExecutor.executeWithAgent(this.agent, {
+                    query: content,
+                    taskId,
+                }));
+            // Emit task:completed
+            this.emit('task:completed', { result, taskId });
+        }
+        catch (error) {
+            // Emit task:error
+            const errorData = serializeTaskError(error);
+            this.emit('task:error', { error: errorData, taskId });
+        }
+        finally {
+            cleanupForwarders();
+        }
+    }
+    /**
+     * Handle task:create request — fire execution asynchronously and return immediately.
+     *
+     * This matches SocketIOTransportClient behavior: request('task:create') resolves
+     * with {taskId} right away, while execution runs in the background emitting events.
+     * The use case registers on() handlers after request() returns, before events arrive.
+     */
+    handleTaskCreate(data) {
+        const taskId = data.taskId;
+        // Fire execution asynchronously — do not await.
+        // Errors are handled internally (emitted as task:error), so the promise never rejects.
+        this.activeTask = this.executeTask(data);
+        return { taskId };
+    }
+    /**
+     * Forward agentEventBus events to registered transport-style handlers.
+     * Returns a cleanup function to remove all forwarders.
+     */
+    setupEventForwarding(taskId) {
+        const eventBus = this.agent.agentEventBus;
+        if (!eventBus) {
+            return () => { };
+        }
+        const forwarders = [];
+        const forward = (busEvent, transportEvent, transform) => {
+            const handler = (payload) => {
+                const data = payload;
+                if (data?.taskId === taskId) {
+                    this.emit(transportEvent, transform ? transform(data) : data);
+                }
+            };
+            eventBus.on(busEvent, handler);
+            forwarders.push({ event: busEvent, handler });
+        };
+        forward('llmservice:toolCall', 'llmservice:toolCall');
+        forward('llmservice:toolResult', 'llmservice:toolResult');
+        forward('llmservice:response', 'llmservice:response');
+        forward('llmservice:error', 'llmservice:error');
+        forward('llmservice:thinking', 'llmservice:thinking');
+        forward('llmservice:chunk', 'llmservice:chunk');
+        forward('llmservice:unsupportedInput', 'llmservice:unsupportedInput');
+        return () => {
+            for (const { event, handler } of forwarders) {
+                eventBus.off(event, handler);
+            }
+        };
+    }
+}

package/dist/infra/space/http-space-service.d.ts

@@ -7,7 +7,7 @@ export type SpaceServiceConfig = {
 export declare class HttpSpaceService implements ISpaceService {
     private readonly config;
     constructor(config: SpaceServiceConfig);
-    getSpaces(accessToken: string, sessionKey: string, teamId: string, option?: {
+    getSpaces(sessionKey: string, teamId: string, option?: {
         fetchAll?: boolean;
         limit?: number;
         offset?: number;

package/dist/infra/space/http-space-service.js

@@ -9,9 +9,9 @@ export class HttpSpaceService {
             timeout: 10_000, // Default 10 seconds timeout
         };
     }
-    async getSpaces(accessToken, sessionKey, teamId, option) {
+    async getSpaces(sessionKey, teamId, option) {
         try {
-            const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
             // Scenario 1: Fetch all automatically via auto-pagination
             if (option?.fetchAll === true) {
                 return await this.fetchAllSpaces(httpClient, teamId);

package/dist/infra/storage/token-store.d.ts

@@ -3,8 +3,9 @@ import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
  * Creates the appropriate token store for the current platform.
  *
  * - WSL: FileTokenStore (encrypted file-based, keychain not available)
- * - macOS/Linux/Windows: KeychainTokenStore (system keychain via keytar)
+ * - Headless Linux: FileTokenStore (no D-Bus/keyring daemon)
+ * - macOS/Windows/Linux with GUI: KeychainTokenStore (system keychain via keytar)
  *
- * @param isWslFn - Optional function to detect WSL (for testing)
+ * @param shouldUseFileFn - Optional function for environment detection (for testing)
  */
-export declare function createTokenStore(isWslFn?: () => boolean): ITokenStore;
+export declare function createTokenStore(shouldUseFileFn?: () => boolean): ITokenStore;

package/dist/infra/storage/token-store.js

@@ -1,14 +1,15 @@
-import { isWsl } from '../../utils/environment-detector.js';
+import { shouldUseFileTokenStore } from '../../utils/environment-detector.js';
 import { FileTokenStore } from './file-token-store.js';
 import { KeychainTokenStore } from './keychain-token-store.js';
 /**
  * Creates the appropriate token store for the current platform.
  *
  * - WSL: FileTokenStore (encrypted file-based, keychain not available)
- * - macOS/Linux/Windows: KeychainTokenStore (system keychain via keytar)
+ * - Headless Linux: FileTokenStore (no D-Bus/keyring daemon)
+ * - macOS/Windows/Linux with GUI: KeychainTokenStore (system keychain via keytar)
  *
- * @param isWslFn - Optional function to detect WSL (for testing)
+ * @param shouldUseFileFn - Optional function for environment detection (for testing)
  */
-export function createTokenStore(isWslFn = isWsl) {
-    return isWslFn() ? new FileTokenStore() : new KeychainTokenStore();
+export function createTokenStore(shouldUseFileFn = shouldUseFileTokenStore) {
+    return shouldUseFileFn() ? new FileTokenStore() : new KeychainTokenStore();
 }

package/dist/infra/team/http-team-service.d.ts

@@ -7,7 +7,7 @@ export type TeamServiceConfig = {
 export declare class HttpTeamService implements ITeamService {
     private readonly config;
     constructor(config: TeamServiceConfig);
-    getTeams(accessToken: string, sessionKey: string, option?: {
+    getTeams(sessionKey: string, option?: {
         fetchAll?: boolean;
         isActive?: boolean;
         limit?: number;

package/dist/infra/team/http-team-service.js

@@ -9,9 +9,9 @@ export class HttpTeamService {
             timeout: 10_000, // Default 10 seconds timeout
         };
     }
-    async getTeams(accessToken, sessionKey, option) {
+    async getTeams(sessionKey, option) {
         try {
-            const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
             // Scenario 1: Fetch all automatically via auto-pagination
             if (option?.fetchAll === true) {
                 return await this.fetchAllTeams(httpClient, option?.isActive);

package/dist/infra/terminal/headless-terminal.d.ts

@@ -0,0 +1,91 @@
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/i-terminal.js';
+/**
+ * Output format for headless terminal.
+ * - 'text': Human-readable text output
+ * - 'json': NDJSON (newline-delimited JSON) for machine parsing
+ */
+export type HeadlessOutputFormat = 'json' | 'text';
+/**
+ * JSON message types for structured output.
+ */
+export type HeadlessMessageType = 'action_start' | 'action_stop' | 'error' | 'log' | 'result' | 'warning';
+/**
+ * Structured JSON output message.
+ */
+export interface HeadlessJsonMessage {
+    actionId?: string;
+    id: string;
+    message: string;
+    timestamp: string;
+    type: HeadlessMessageType;
+}
+/**
+ * Options for creating a HeadlessTerminal.
+ */
+export interface HeadlessTerminalOptions {
+    /**
+     * Stream for errors (defaults to process.stderr).
+     */
+    errorStream?: NodeJS.WritableStream;
+    /**
+     * If true, throw HeadlessPromptError when a prompt cannot be answered.
+     * If false, use sensible defaults (first choice, false for confirm, etc.)
+     * @default true
+     */
+    failOnPrompt?: boolean;
+    /**
+     * Output format: 'text' for human readable, 'json' for machine parsing.
+     * @default 'text'
+     */
+    outputFormat?: HeadlessOutputFormat;
+    /**
+     * Stream for output (defaults to process.stdout).
+     */
+    outputStream?: NodeJS.WritableStream;
+    /**
+     * Default values for prompts, keyed by prompt message or prompt type.
+     * Used to answer prompts automatically in headless mode.
+     */
+    promptDefaults?: Record<string, unknown>;
+}
+/**
+ * Terminal implementation for headless/non-interactive mode.
+ * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
+ */
+export declare class HeadlessTerminal implements ITerminal {
+    private currentActionId;
+    private readonly errorOutput;
+    private readonly failOnPrompt;
+    private readonly output;
+    private readonly outputFormat;
+    private readonly promptDefaults;
+    constructor(options?: HeadlessTerminalOptions);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm(options: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input(options: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>(options: SearchOptions<T>): Promise<T>;
+    select<T>(options: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+    /**
+     * Write final response with success/error status.
+     */
+    writeFinalResponse(response: {
+        command: string;
+        data?: unknown;
+        error?: {
+            code: string;
+            message: string;
+        };
+        success: boolean;
+    }): void;
+    /**
+     * Write final result in JSON format (convenience method for commands).
+     */
+    writeResult(data: Record<string, unknown>): void;
+    private getDefault;
+    private writeJson;
+}

package/dist/infra/terminal/headless-terminal.js

@@ -0,0 +1,211 @@
+import { randomUUID } from 'node:crypto';
+import { HeadlessPromptError } from '../../core/domain/errors/headless-prompt-error.js';
+/**
+ * Terminal implementation for headless/non-interactive mode.
+ * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
+ */
+export class HeadlessTerminal {
+    currentActionId = null;
+    errorOutput;
+    failOnPrompt;
+    output;
+    outputFormat;
+    promptDefaults;
+    constructor(options = {}) {
+        this.outputFormat = options.outputFormat ?? 'text';
+        this.promptDefaults = options.promptDefaults ?? {};
+        this.failOnPrompt = options.failOnPrompt ?? true;
+        this.output = options.outputStream ?? process.stdout;
+        this.errorOutput = options.errorStream ?? process.stderr;
+    }
+    // ==================== Output Methods ====================
+    actionStart(message) {
+        this.currentActionId = randomUUID();
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                actionId: this.currentActionId,
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'action_start',
+            });
+        }
+        // In text mode, suppress action start for cleaner output
+    }
+    actionStop(message) {
+        if (this.outputFormat === 'json' && this.currentActionId) {
+            this.writeJson({
+                actionId: this.currentActionId,
+                id: randomUUID(),
+                message: message ?? '',
+                timestamp: new Date().toISOString(),
+                type: 'action_stop',
+            });
+        }
+        this.currentActionId = null;
+    }
+    async confirm(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('confirm', options.message);
+        if (defaultValue !== undefined) {
+            return Boolean(defaultValue);
+        }
+        // Use options.default if provided
+        if (options.default !== undefined) {
+            return options.default;
+        }
+        // Fail or return false
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('confirm', options.message);
+        }
+        return false;
+    }
+    error(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'error',
+            });
+        }
+        else {
+            this.errorOutput.write(`Error: ${message}\n`);
+        }
+    }
+    async fileSelector(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('file_selector', options.message);
+        if (defaultValue !== undefined && typeof defaultValue === 'string') {
+            return {
+                isDirectory: options.type === 'directory',
+                name: defaultValue.split('/').pop() ?? defaultValue,
+                path: defaultValue,
+            };
+        }
+        // Allow cancel if specified
+        if (options.allowCancel) {
+            return null;
+        }
+        // Fail
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('file_selector', options.message);
+        }
+        return null;
+    }
+    // ==================== Input Methods ====================
+    async input(options) {
+        // Check for explicit default in promptDefaults
+        const defaultValue = this.getDefault('input', options.message);
+        if (defaultValue !== undefined) {
+            const value = String(defaultValue);
+            // Validate if validator is provided
+            if (options.validate) {
+                const validationResult = options.validate(value);
+                if (validationResult !== true) {
+                    const errorMsg = typeof validationResult === 'string' ? validationResult : 'Validation failed';
+                    throw new HeadlessPromptError('input', `${options.message} (validation error: ${errorMsg})`);
+                }
+            }
+            return value;
+        }
+        // Fail
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('input', options.message);
+        }
+        return '';
+    }
+    log(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message: message ?? '',
+                timestamp: new Date().toISOString(),
+                type: 'log',
+            });
+        }
+        else {
+            this.output.write((message ?? '') + '\n');
+        }
+    }
+    async search(options) {
+        // Search prompts require user interaction - always fail in headless mode
+        // unless a default is explicitly provided
+        const defaultValue = this.getDefault('search', options.message);
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new HeadlessPromptError('search', options.message);
+    }
+    async select(options) {
+        // Check for explicit default in promptDefaults (by value or name)
+        const defaultValue = this.getDefault('select', options.message);
+        if (defaultValue !== undefined) {
+            const choice = options.choices.find((c) => c.value === defaultValue || c.name === defaultValue);
+            if (choice) {
+                return choice.value;
+            }
+        }
+        // Fail or return first choice
+        if (this.failOnPrompt) {
+            throw new HeadlessPromptError('select', options.message, options.choices.map((c) => c.name));
+        }
+        // Return first choice as fallback
+        if (options.choices.length > 0) {
+            return options.choices[0].value;
+        }
+        throw new HeadlessPromptError('select', options.message, []);
+    }
+    warn(message) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message,
+                timestamp: new Date().toISOString(),
+                type: 'warning',
+            });
+        }
+        else {
+            this.errorOutput.write(`Warning: ${message}\n`);
+        }
+    }
+    // ==================== Helper Methods ====================
+    /**
+     * Write final response with success/error status.
+     */
+    writeFinalResponse(response) {
+        if (this.outputFormat === 'json') {
+            this.output.write(JSON.stringify({
+                ...response,
+                timestamp: new Date().toISOString(),
+            }) + '\n');
+        }
+    }
+    /**
+     * Write final result in JSON format (convenience method for commands).
+     */
+    writeResult(data) {
+        if (this.outputFormat === 'json') {
+            this.writeJson({
+                id: randomUUID(),
+                message: JSON.stringify(data),
+                timestamp: new Date().toISOString(),
+                type: 'result',
+            });
+        }
+    }
+    getDefault(promptType, promptMessage) {
+        // First check by exact message
+        if (this.promptDefaults[promptMessage] !== undefined) {
+            return this.promptDefaults[promptMessage];
+        }
+        // Then check by prompt type
+        if (this.promptDefaults[promptType] !== undefined) {
+            return this.promptDefaults[promptType];
+        }
+        return undefined;
+    }
+    writeJson(data) {
+        this.output.write(JSON.stringify(data) + '\n');
+    }
+}