byterover-cli 1.4.0 → 1.6.0

package/dist/infra/usecase/curate-use-case.d.ts

@@ -1,7 +1,31 @@
+import { z } from 'zod';
 import type { ITerminal } from '../../core/interfaces/i-terminal.js';
 import type { CurateUseCaseRunOptions, ICurateUseCase } from '../../core/interfaces/usecase/i-curate-use-case.js';
 import { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
 import { type TransportClientFactory } from '../transport/transport-client-factory.js';
+declare const CurateOperationSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    path: z.ZodString;
+    status: z.ZodEnum<["success", "failed"]>;
+    type: z.ZodEnum<["ADD", "UPDATE", "MERGE", "DELETE"]>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "DELETE" | "ADD" | "UPDATE" | "MERGE";
+    status: "failed" | "success";
+    filePath: string;
+}, {
+    path: string;
+    type: "DELETE" | "ADD" | "UPDATE" | "MERGE";
+    status: "failed" | "success";
+    filePath: string;
+}>;
+type CurateOperation = z.infer<typeof CurateOperationSchema>;
+export interface CurateResult {
+    message: string;
+    operations?: CurateOperation[];
+    status: 'completed' | 'error' | 'queued';
+    taskId?: string;
+}
 export type TransportClientFactoryCreator = () => TransportClientFactory;
 export interface CurateUseCaseOptions {
     terminal: ITerminal;
@@ -14,6 +38,21 @@ export declare class CurateUseCase implements ICurateUseCase {
     private readonly trackingService;
     private readonly transportClientFactoryCreator;
     constructor(options: CurateUseCaseOptions);
-    run({ context, files, verbose }: CurateUseCaseRunOptions): Promise<void>;
+    run({ context, files, format, headless, verbose, }: CurateUseCaseRunOptions): Promise<void>;
+    private createClient;
     private handleConnectionError;
+    /**
+     * Handle connection errors with JSON output.
+     */
+    private handleConnectionErrorJson;
+    /**
+     * Output JSON result for headless mode.
+     */
+    private outputJsonResult;
+    /**
+     * Wait for task completion in headless mode.
+     * Listens for task:completed or task:error events before returning.
+     */
+    private waitForTaskCompletion;
 }
+export {};

package/dist/infra/usecase/curate-use-case.js

@@ -1,8 +1,25 @@
 import { randomUUID } from 'node:crypto';
-import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanceRunningError } from '../../core/domain/errors/connection-error.js';
+import { z } from 'zod';
+import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanceRunningError, } from '../../core/domain/errors/connection-error.js';
 import { formatError } from '../../utils/error-handler.js';
 import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from '../../utils/sandbox-detector.js';
+import { ToolName } from '../cipher/tools/index.js';
+import { InlineAgent } from '../process/inline-agent-executor.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 import { createTransportClientFactory } from '../transport/transport-client-factory.js';
+const CurateOperationSchema = z.object({
+    filePath: z.string(),
+    path: z.string(),
+    status: z.enum(['success', 'failed']),
+    type: z.enum(['ADD', 'UPDATE', 'MERGE', 'DELETE']),
+});
+const CurateResultSchema = z.object({
+    result: z
+        .object({
+        applied: z.array(CurateOperationSchema).optional(),
+    })
+        .optional(),
+});
 export class CurateUseCase {
     terminal;
     trackingService;
@@ -12,27 +29,27 @@ export class CurateUseCase {
         this.trackingService = options.trackingService;
         this.transportClientFactoryCreator = options.transportClientFactoryCreator ?? createTransportClientFactory;
     }
-    async run({ context, files, verbose = false }) {
+    async run({ context, files, format = 'text', headless = false, verbose = false, }) {
         await this.trackingService.track('mem:curate', { status: 'started' });
         const hasContext = Boolean(context?.trim());
         const hasFiles = Boolean(files?.length);
         if (!hasContext && !hasFiles) {
-            this.terminal.log('Either a context argument or file reference is required.');
-            this.terminal.log('Usage:');
-            this.terminal.log('  brv curate "your context here"');
-            this.terminal.log('  brv curate @src/file.ts');
-            this.terminal.log('  brv curate "context with files" @src/file.ts');
+            if (format === 'json') {
+                this.outputJsonResult({ message: 'Either a context argument or file reference is required.', status: 'error' });
+            }
+            else {
+                this.terminal.log('Either a context argument or file reference is required.');
+                this.terminal.log('Usage:');
+                this.terminal.log('  brv curate "your context here"');
+                this.terminal.log('  brv curate @src/file.ts');
+                this.terminal.log('  brv curate "context with files" @src/file.ts');
+            }
             return;
         }
         const resolvedContent = context?.trim() ? context : '';
         let client;
         try {
-            const transportClientFactory = this.transportClientFactoryCreator();
-            if (verbose) {
-                this.terminal.log('Discovering running instance...');
-            }
-            const { client: connectedClient } = await transportClientFactory.connect();
-            client = connectedClient;
+            client = await this.createClient({ headless, verbose });
             if (verbose) {
                 this.terminal.log(`Connected to instance (clientId: ${client.getClientId()})`);
             }
@@ -45,11 +62,25 @@ export class CurateUseCase {
                 taskId,
                 type: 'curate',
             });
-            this.terminal.log('✓ Context queued for processing.');
+            if (headless) {
+                // In headless mode, wait for the in-process task to complete
+                await this.waitForTaskCompletion(client, taskId, format);
+            }
+            else if (format === 'json') {
+                this.outputJsonResult({ message: 'Context queued for processing', status: 'queued', taskId });
+            }
+            else {
+                this.terminal.log('✓ Context queued for processing.');
+            }
             await this.trackingService.track('mem:curate', { status: 'finished' });
         }
         catch (error) {
-            this.handleConnectionError(error);
+            if (format === 'json') {
+                this.handleConnectionErrorJson(error);
+            }
+            else {
+                this.handleConnectionError(error);
+            }
             await this.trackingService.track('mem:curate', { message: formatError(error), status: 'error' });
         }
         finally {
@@ -58,6 +89,18 @@ export class CurateUseCase {
             }
         }
     }
+    async createClient(options) {
+        if (options.headless) {
+            const inlineAgent = await InlineAgent.create();
+            return inlineAgent.transportClient;
+        }
+        const transportClientFactory = this.transportClientFactoryCreator();
+        if (options.verbose) {
+            this.terminal.log('Discovering running instance...');
+        }
+        const { client: connectedClient } = await transportClientFactory.connect();
+        return connectedClient;
+    }
     handleConnectionError(error) {
         if (error instanceof NoInstanceRunningError) {
             // Check if running in sandbox environment
@@ -100,4 +143,122 @@ export class CurateUseCase {
         const message = error instanceof Error ? error.message : String(error);
         this.terminal.log(`Unexpected error: ${message}`);
     }
+    /**
+     * Handle connection errors with JSON output.
+     */
+    handleConnectionErrorJson(error) {
+        let errorMessage = 'An unexpected error occurred';
+        if (error instanceof NoInstanceRunningError) {
+            errorMessage = 'No ByteRover instance is running. Start one with: brv';
+        }
+        else if (error instanceof InstanceCrashedError) {
+            errorMessage = 'ByteRover instance has crashed. Please restart with: brv';
+        }
+        else if (error instanceof ConnectionFailedError) {
+            errorMessage = `Failed to connect to ByteRover instance: ${error.message}`;
+        }
+        else if (error instanceof ConnectionError) {
+            errorMessage = `Connection error: ${error.message}`;
+        }
+        else if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        this.outputJsonResult({ message: errorMessage, status: 'error' });
+    }
+    /**
+     * Output JSON result for headless mode.
+     */
+    outputJsonResult(result) {
+        const response = {
+            command: 'curate',
+            data: result,
+            success: result.status !== 'error',
+            timestamp: new Date().toISOString(),
+        };
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
+    /**
+     * Wait for task completion in headless mode.
+     * Listens for task:completed or task:error events before returning.
+     */
+    async waitForTaskCompletion(client, taskId, format) {
+        return new Promise((resolve, reject) => {
+            let completed = false;
+            const operations = [];
+            const timeout = setTimeout(() => {
+                if (!completed) {
+                    completed = true;
+                    cleanup();
+                    if (format === 'json') {
+                        this.outputJsonResult({ message: 'Task timed out after 5 minutes', status: 'error' });
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Task timed out after 5 minutes'));
+                    }
+                }
+            }, 5 * 60 * 1000);
+            const unsubscribers = [
+                client.on('llmservice:toolResult', (payload) => {
+                    if (payload.success && payload.toolName === ToolName.CURATE && payload.result) {
+                        try {
+                            const parsed = CurateResultSchema.parse(JSON.parse(payload.result));
+                            for (const op of parsed.result?.applied ?? []) {
+                                if (op.status === 'success') {
+                                    operations.push(op);
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    }
+                }),
+                client.on('task:completed', (payload) => {
+                    if (payload.taskId === taskId && !completed) {
+                        completed = true;
+                        cleanup();
+                        if (format === 'json') {
+                            this.outputJsonResult({
+                                message: 'Context curated successfully',
+                                operations: operations.length > 0 ? operations : undefined,
+                                status: 'completed',
+                                taskId,
+                            });
+                        }
+                        else {
+                            for (const op of operations) {
+                                this.terminal.log(`  ${op.type.toLowerCase()} ${op.filePath}`);
+                            }
+                            this.terminal.log('✓ Context curated successfully.');
+                        }
+                        resolve();
+                    }
+                }),
+                client.on('task:error', (payload) => {
+                    if (payload.taskId === taskId && !completed) {
+                        completed = true;
+                        cleanup();
+                        if (format === 'json') {
+                            this.outputJsonResult({ message: payload.error.message, status: 'error' });
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(payload.error.message));
+                        }
+                    }
+                }),
+                () => clearTimeout(timeout),
+            ];
+            const cleanup = () => {
+                for (const unsub of unsubscribers)
+                    unsub();
+            };
+        });
+    }
 }

package/dist/infra/usecase/init-use-case.d.ts

@@ -13,9 +13,19 @@ import type { ITeamService } from '../../core/interfaces/i-team-service.js';
 import type { ITerminal } from '../../core/interfaces/i-terminal.js';
 import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
-import type { IInitUseCase } from '../../core/interfaces/usecase/i-init-use-case.js';
+import type { IInitUseCase, InitUseCaseRunOptions } from '../../core/interfaces/usecase/i-init-use-case.js';
 import { type Agent } from '../../core/domain/entities/agent.js';
 import { BrvConfig } from '../../core/domain/entities/brv-config.js';
+/**
+ * Structured init result for JSON output.
+ */
+export interface InitResult {
+    configPath?: string;
+    error?: string;
+    spaceName?: string;
+    status: 'cancelled' | 'error' | 'success';
+    teamName?: string;
+}
 /**
  * Represents a legacy config that exists but has version issues.
  * Used to display config info during re-initialization prompt.
@@ -64,9 +74,19 @@ export declare class InitUseCase implements IInitUseCase {
         chatLogPath: string;
         cwd: string;
     };
-    protected ensureAuthenticated(): Promise<AuthToken | undefined>;
+    protected ensureAuthenticated(format: 'json' | 'text'): Promise<AuthToken | undefined>;
     protected fetchAndSelectSpace(token: AuthToken, team: Team): Promise<Space | undefined>;
     protected fetchAndSelectTeam(token: AuthToken): Promise<Team | undefined>;
+    /**
+     * Fetch space by ID or name for headless mode.
+     * First tries to match by ID, then by name (case-insensitive).
+     */
+    protected fetchSpaceById(token: AuthToken, team: Team, spaceIdOrName: string, format: 'json' | 'text'): Promise<Space | undefined>;
+    /**
+     * Fetch team by ID or name for headless mode.
+     * First tries to match by ID, then by name (case-insensitive).
+     */
+    protected fetchTeamById(token: AuthToken, teamIdOrName: string, format: 'json' | 'text'): Promise<Team | undefined>;
     protected getExistingConfig(): Promise<BrvConfig | LegacyProjectConfigInfo | undefined>;
     protected initializeMemoryContextDir(name: string, initFn: () => Promise<string>): Promise<void>;
     /**
@@ -90,9 +110,7 @@ export declare class InitUseCase implements IInitUseCase {
     protected promptForSpaceSelection(spaces: Space[]): Promise<Space | undefined>;
     protected promptForTeamSelection(teams: Team[]): Promise<Team | undefined>;
     protected removeAceDirectory(baseDir?: string): Promise<void>;
-    run(options: {
-        force: boolean;
-    }): Promise<void>;
+    run(options: InitUseCaseRunOptions): Promise<void>;
     protected syncFromRemoteOrInitialize(params: {
         projectConfig: {
             spaceId: string;
@@ -101,4 +119,8 @@ export declare class InitUseCase implements IInitUseCase {
         token: AuthToken;
     }): Promise<void>;
     private logSuccess;
+    /**
+     * Output JSON result for headless mode.
+     */
+    private outputJsonResult;
 }

package/dist/infra/usecase/init-use-case.js

@@ -5,6 +5,7 @@ import { ACE_DIR, BRV_CONFIG_VERSION, BRV_DIR, DEFAULT_BRANCH, PROJECT_CONFIG_FI
 import { AGENT_VALUES } from '../../core/domain/entities/agent.js';
 import { BrvConfig } from '../../core/domain/entities/brv-config.js';
 import { BrvConfigVersionError } from '../../core/domain/errors/brv-config-version-error.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 import { WorkspaceDetectorService } from '../workspace/workspace-detector-service.js';
 export class InitUseCase {
     cogitPullService;
@@ -88,21 +89,31 @@ export class InitUseCase {
             cwd: result.cwd,
         };
     }
-    async ensureAuthenticated() {
+    async ensureAuthenticated(format) {
         const token = await this.tokenStore.load();
         if (token === undefined) {
-            this.terminal.log('Not authenticated. Please run "/login" first.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Not authenticated. Run login first.', status: 'error' });
+            }
+            else {
+                this.terminal.log('Not authenticated. Please run "/login" first.');
+            }
             return undefined;
         }
         if (!token.isValid()) {
-            this.terminal.log('Authentication token expired. Please run "/login" again.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Authentication token expired. Run login again.', status: 'error' });
+            }
+            else {
+                this.terminal.log('Authentication token expired. Please run "/login" again.');
+            }
             return undefined;
         }
         return token;
     }
     async fetchAndSelectSpace(token, team) {
         this.terminal.actionStart('Fetching all spaces');
-        const { spaces } = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, team.id, { fetchAll: true });
+        const { spaces } = await this.spaceService.getSpaces(token.sessionKey, team.id, { fetchAll: true });
         this.terminal.actionStop();
         if (spaces.length === 0) {
             this.terminal.error(`No spaces found in team "${team.getDisplayName()}"\nPlease visit ${getCurrentConfig().webAppUrl} to create your first space for ${team.getDisplayName()}.`);
@@ -113,7 +124,7 @@ export class InitUseCase {
     }
     async fetchAndSelectTeam(token) {
         this.terminal.actionStart('Fetching all teams');
-        const { teams } = await this.teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        const { teams } = await this.teamService.getTeams(token.sessionKey, { fetchAll: true });
         this.terminal.actionStop();
         if (teams.length === 0) {
             this.terminal.error(`No teams found.\nPlease visit ${getCurrentConfig().webAppUrl} to create your first team.`);
@@ -122,6 +133,82 @@ export class InitUseCase {
         this.terminal.log();
         return this.promptForTeamSelection(teams);
     }
+    /**
+     * Fetch space by ID or name for headless mode.
+     * First tries to match by ID, then by name (case-insensitive).
+     */
+    async fetchSpaceById(token, team, spaceIdOrName, format) {
+        this.terminal.actionStart('Fetching space');
+        try {
+            const { spaces } = await this.spaceService.getSpaces(token.sessionKey, team.id, { fetchAll: true });
+            this.terminal.actionStop();
+            // First try to find by ID
+            let space = spaces.find((s) => s.id === spaceIdOrName);
+            // If not found by ID, try to find by name (case-insensitive)
+            if (!space) {
+                space = spaces.find((s) => s.name.toLowerCase() === spaceIdOrName.toLowerCase());
+            }
+            if (!space) {
+                if (format === 'json') {
+                    this.outputJsonResult({ error: `Space "${spaceIdOrName}" not found in team "${team.name}"`, status: 'error' });
+                }
+                else {
+                    this.terminal.error(`Space "${spaceIdOrName}" not found in team "${team.name}"`);
+                }
+                return undefined;
+            }
+            return space;
+        }
+        catch (error) {
+            this.terminal.actionStop();
+            const message = error instanceof Error ? error.message : 'Failed to fetch space';
+            if (format === 'json') {
+                this.outputJsonResult({ error: message, status: 'error' });
+            }
+            else {
+                this.terminal.error(message);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * Fetch team by ID or name for headless mode.
+     * First tries to match by ID, then by name (case-insensitive).
+     */
+    async fetchTeamById(token, teamIdOrName, format) {
+        this.terminal.actionStart('Fetching team');
+        try {
+            const { teams } = await this.teamService.getTeams(token.sessionKey, { fetchAll: true });
+            this.terminal.actionStop();
+            // First try to find by ID
+            let team = teams.find((t) => t.id === teamIdOrName);
+            // If not found by ID, try to find by name (case-insensitive)
+            if (!team) {
+                team = teams.find((t) => t.name.toLowerCase() === teamIdOrName.toLowerCase());
+            }
+            if (!team) {
+                if (format === 'json') {
+                    this.outputJsonResult({ error: `Team "${teamIdOrName}" not found`, status: 'error' });
+                }
+                else {
+                    this.terminal.error(`Team "${teamIdOrName}" not found`);
+                }
+                return undefined;
+            }
+            return team;
+        }
+        catch (error) {
+            this.terminal.actionStop();
+            const message = error instanceof Error ? error.message : 'Failed to fetch team';
+            if (format === 'json') {
+                this.outputJsonResult({ error: message, status: 'error' });
+            }
+            else {
+                this.terminal.error(message);
+            }
+            return undefined;
+        }
+    }
     async getExistingConfig() {
         const exists = await this.projectConfigStore.exists();
         if (!exists)
@@ -266,37 +353,80 @@ export class InitUseCase {
         await rm(acePath, { force: true, recursive: true });
     }
     async run(options) {
+        const format = options.format ?? 'text';
+        const isHeadless = Boolean(options.teamId && options.spaceId);
         try {
             await this.trackingService.track('init', { status: 'started' });
-            const authToken = await this.ensureAuthenticated();
+            const authToken = await this.ensureAuthenticated(format);
             if (!authToken)
                 return;
             const existingConfig = await this.getExistingConfig();
             if (existingConfig) {
-                const shouldCleanup = options.force ? true : await this.confirmReInitialization(existingConfig);
-                if (shouldCleanup) {
-                    await this.cleanupBeforeReInitialization();
-                    this.terminal.log('\n');
+                // In headless mode with force, always cleanup
+                // In headless mode without force, fail
+                // In interactive mode, prompt for confirmation
+                if (isHeadless) {
+                    if (options.force) {
+                        await this.cleanupBeforeReInitialization();
+                    }
+                    else {
+                        if (format === 'json') {
+                            this.outputJsonResult({
+                                error: 'Project already initialized. Use --force to re-initialize.',
+                                status: 'error',
+                            });
+                        }
+                        else {
+                            this.terminal.error('Project already initialized. Use --force to re-initialize.');
+                        }
+                        return;
+                    }
                 }
                 else {
-                    this.terminal.log('\nCancelled. Project configuration unchanged.');
-                    return;
+                    const shouldCleanup = options.force ? true : await this.confirmReInitialization(existingConfig);
+                    if (shouldCleanup) {
+                        await this.cleanupBeforeReInitialization();
+                        this.terminal.log('\n');
+                    }
+                    else {
+                        if (format === 'json') {
+                            this.outputJsonResult({ status: 'cancelled' });
+                        }
+                        else {
+                            this.terminal.log('\nCancelled. Project configuration unchanged.');
+                        }
+                        return;
+                    }
                 }
             }
             this.terminal.log('Initializing ByteRover project...\n');
-            const selectedTeam = await this.fetchAndSelectTeam(authToken);
-            if (!selectedTeam)
-                return;
-            const selectedSpace = await this.fetchAndSelectSpace(authToken, selectedTeam);
-            if (!selectedSpace)
-                return;
-            // Handle ACE deprecation - check for existing ACE folder and offer removal
-            const aceExists = await this.aceDirectoryExists();
-            if (aceExists) {
-                const shouldRemoveAce = await this.promptAceDeprecationRemoval();
-                if (shouldRemoveAce) {
-                    await this.removeAceDirectory();
-                    this.terminal.log('✓ ACE folder removed');
+            let selectedTeam;
+            let selectedSpace;
+            if (isHeadless && options.teamId && options.spaceId) {
+                // Headless mode: fetch team and space by ID
+                selectedTeam = await this.fetchTeamById(authToken, options.teamId, format);
+                if (!selectedTeam)
+                    return;
+                selectedSpace = await this.fetchSpaceById(authToken, selectedTeam, options.spaceId, format);
+                if (!selectedSpace)
+                    return;
+            }
+            else {
+                // Interactive mode: prompt for selection
+                selectedTeam = await this.fetchAndSelectTeam(authToken);
+                if (!selectedTeam)
+                    return;
+                selectedSpace = await this.fetchAndSelectSpace(authToken, selectedTeam);
+                if (!selectedSpace)
+                    return;
+                // Handle ACE deprecation - check for existing ACE folder and offer removal
+                const aceExists = await this.aceDirectoryExists();
+                if (aceExists) {
+                    const shouldRemoveAce = await this.promptAceDeprecationRemoval();
+                    if (shouldRemoveAce) {
+                        await this.removeAceDirectory();
+                        this.terminal.log('✓ ACE folder removed');
+                    }
                 }
             }
             // Sync from remote or initialize context tree with templates
@@ -304,8 +434,11 @@ export class InitUseCase {
                 projectConfig: { spaceId: selectedSpace.id, teamId: selectedTeam.id },
                 token: authToken,
             });
-            this.terminal.log();
-            const selectedAgent = await this.promptForAgentSelection();
+            let selectedAgent = 'Claude Code';
+            if (!isHeadless) {
+                this.terminal.log();
+                selectedAgent = await this.promptForAgentSelection();
+            }
             const { chatLogPath, cwd } = this.detectWorkspacesForAgent(selectedAgent);
             this.terminal.log(`✓ Detected workspace: ${cwd}`);
             const config = BrvConfig.fromSpace({
@@ -315,18 +448,35 @@ export class InitUseCase {
                 space: selectedSpace,
             });
             await this.projectConfigStore.write(config);
-            this.terminal.log();
-            await this.installConnectorForAgent(selectedAgent);
+            if (!isHeadless) {
+                this.terminal.log();
+                await this.installConnectorForAgent(selectedAgent);
+            }
             await this.trackingService.track('space:init');
-            this.logSuccess(selectedSpace);
+            if (format === 'json') {
+                this.outputJsonResult({
+                    configPath: join(process.cwd(), BRV_DIR, PROJECT_CONFIG_FILE),
+                    spaceName: selectedSpace.getDisplayName(),
+                    status: 'success',
+                    teamName: selectedTeam.name,
+                });
+            }
+            else {
+                this.logSuccess(selectedSpace);
+            }
             await this.trackingService.track('init', { status: 'finished' });
         }
         catch (error) {
             // Stop action if it's in progress
             this.terminal.actionStop();
-            const initErr = `Initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
-            await this.trackingService.track('init', { message: initErr, status: 'error' });
-            this.terminal.error(initErr);
+            const initErr = error instanceof Error ? error.message : 'Unknown error';
+            await this.trackingService.track('init', { message: `Initialization failed: ${initErr}`, status: 'error' });
+            if (format === 'json') {
+                this.outputJsonResult({ error: initErr, status: 'error' });
+            }
+            else {
+                this.terminal.error(`Initialization failed: ${initErr}`);
+            }
         }
     }
     async syncFromRemoteOrInitialize(params) {
@@ -334,7 +484,6 @@ export class InitUseCase {
         this.terminal.actionStart('Syncing from ByteRover...');
         try {
             const coGitSnapshot = await this.cogitPullService.pull({
-                accessToken: params.token.accessToken,
                 branch: DEFAULT_BRANCH,
                 sessionKey: params.token.sessionKey,
                 spaceId: params.projectConfig.spaceId,
@@ -369,4 +518,21 @@ export class InitUseCase {
         this.terminal.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
         this.terminal.log("NOTE: It's recommended to add .brv/ to your .gitignore file since ByteRover already takes care of memory/context versioning for you.");
     }
+    /**
+     * Output JSON result for headless mode.
+     */
+    outputJsonResult(result) {
+        const response = {
+            command: 'init',
+            data: result,
+            success: result.status === 'success',
+            timestamp: new Date().toISOString(),
+        };
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
 }