byterover-cli 2.1.5 → 2.3.0

package/dist/server/infra/transport/handlers/provider-handler.js

@@ -4,17 +4,29 @@ import { TransportDaemonEventNames } from '../../../core/domain/transport/schema
 import { getErrorMessage } from '../../../utils/error-helpers.js';
 import { processLog } from '../../../utils/process-logger.js';
 import { validateApiKey as validateApiKeyViaFetcher } from '../../http/provider-model-fetcher-registry.js';
+import { computeExpiresAt, exchangeCodeForTokens as defaultExchangeCodeForTokens, generatePkce as defaultGeneratePkce, parseAccountIdFromIdToken, ProviderCallbackServer, ProviderCallbackTimeoutError, } from '../../provider-oauth/index.js';
 /**
  * Handles provider:* events.
  * Business logic for provider management — no terminal/UI calls.
  */
 export class ProviderHandler {
+    browserLauncher;
+    createCallbackServer;
+    exchangeCodeForTokens;
+    generatePkce;
+    oauthFlows = new Map();
     providerConfigStore;
     providerKeychainStore;
+    providerOAuthTokenStore;
     transport;
     constructor(deps) {
+        this.browserLauncher = deps.browserLauncher;
+        this.createCallbackServer = deps.createCallbackServer ?? ((options) => new ProviderCallbackServer(options));
+        this.exchangeCodeForTokens = deps.exchangeCodeForTokens ?? defaultExchangeCodeForTokens;
+        this.generatePkce = deps.generatePkce ?? defaultGeneratePkce;
         this.providerConfigStore = deps.providerConfigStore;
         this.providerKeychainStore = deps.providerKeychainStore;
+        this.providerOAuthTokenStore = deps.providerOAuthTokenStore;
         this.transport = deps.transport;
     }
     setup() {
@@ -24,6 +36,99 @@ export class ProviderHandler {
         this.setupList();
         this.setupSetActive();
         this.setupValidateApiKey();
+        this.setupStartOAuth();
+        this.setupAwaitOAuthCallback();
+        this.setupCancelOAuth();
+        this.setupSubmitOAuthCode();
+        // Clean up OAuth flows when a client disconnects (prevents callback server port leaks)
+        this.transport.onDisconnection((clientId) => {
+            this.cleanupFlowsForClient(clientId);
+        });
+    }
+    cleanupFlowsForClient(clientId) {
+        for (const [providerId, flow] of this.oauthFlows.entries()) {
+            if (flow.clientId === clientId) {
+                flow.callbackServer?.stop().catch(() => { });
+                this.oauthFlows.delete(providerId);
+            }
+        }
+    }
+    setupAwaitOAuthCallback() {
+        this.transport.onRequest(ProviderEvents.AWAIT_OAUTH_CALLBACK, async (data) => {
+            const flow = this.oauthFlows.get(data.providerId);
+            if (!flow?.callbackServer) {
+                return { error: 'No active OAuth flow for this provider', success: false };
+            }
+            if (flow.awaitInProgress) {
+                return { error: 'OAuth callback is already being awaited for this provider', success: false };
+            }
+            flow.awaitInProgress = true;
+            try {
+                // Block until callback or timeout (5 min default in ProviderCallbackServer)
+                const callbackResult = await flow.callbackServer.waitForCallback(flow.state);
+                // Exchange code for tokens
+                const providerDef = getProviderById(data.providerId);
+                if (!providerDef?.oauth) {
+                    return { error: 'Provider does not support OAuth', success: false };
+                }
+                const oauthConfig = providerDef.oauth;
+                const contentType = oauthConfig.tokenContentType === 'form' ? 'application/x-www-form-urlencoded' : 'application/json';
+                const tokens = await this.exchangeCodeForTokens({
+                    clientId: oauthConfig.clientId,
+                    code: callbackResult.code,
+                    codeVerifier: flow.codeVerifier,
+                    contentType,
+                    redirectUri: oauthConfig.redirectUri,
+                    tokenUrl: oauthConfig.tokenUrl,
+                });
+                // Parse JWT id_token for account ID
+                const oauthAccountId = tokens.id_token ? parseAccountIdFromIdToken(tokens.id_token) : undefined;
+                // Store access token as the "API key" in keychain
+                await this.providerKeychainStore.setApiKey(data.providerId, tokens.access_token);
+                // Store refresh token + expiry in encrypted OAuth token store
+                if (tokens.refresh_token) {
+                    const expiresAt = tokens.expires_in ? computeExpiresAt(tokens.expires_in) : computeExpiresAt(3600); // 1-hour default when provider omits expires_in
+                    await this.providerOAuthTokenStore.set(data.providerId, {
+                        expiresAt,
+                        refreshToken: tokens.refresh_token,
+                    });
+                }
+                // Connect provider — secrets stored in keychain + encrypted token store, not config
+                // OAuth providers may define their own default model (e.g., Codex for OpenAI OAuth)
+                const defaultModel = oauthConfig.defaultModel ?? providerDef.defaultModel;
+                await this.providerConfigStore.connectProvider(data.providerId, {
+                    activeModel: defaultModel,
+                    authMethod: 'oauth',
+                    oauthAccountId,
+                });
+                // Broadcast update
+                this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+                return { success: true };
+            }
+            catch (error) {
+                if (error instanceof ProviderCallbackTimeoutError) {
+                    return { error: 'Authentication timed out. Please try again.', success: false };
+                }
+                return { error: getErrorMessage(error), success: false };
+            }
+            finally {
+                // Only clean up if this is still the same flow (guard against concurrent START_OAUTH)
+                if (this.oauthFlows.get(data.providerId) === flow) {
+                    await flow.callbackServer?.stop().catch(() => { });
+                    this.oauthFlows.delete(data.providerId);
+                }
+            }
+        });
+    }
+    setupCancelOAuth() {
+        this.transport.onRequest(ProviderEvents.CANCEL_OAUTH, async (data) => {
+            const flow = this.oauthFlows.get(data.providerId);
+            if (flow?.callbackServer) {
+                await flow.callbackServer.stop().catch(() => { });
+            }
+            this.oauthFlows.delete(data.providerId);
+            return { success: true };
+        });
     }
     setupConnect() {
         this.transport.onRequest(ProviderEvents.CONNECT, async (data) => {
@@ -35,6 +140,7 @@ export class ProviderHandler {
             const provider = getProviderById(providerId);
             await this.providerConfigStore.connectProvider(providerId, {
                 activeModel: provider?.defaultModel,
+                authMethod: apiKey ? 'api-key' : undefined,
                 baseUrl,
             });
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
@@ -46,6 +152,7 @@ export class ProviderHandler {
             const { providerId } = data;
             await this.providerConfigStore.disconnectProvider(providerId);
             await this.providerKeychainStore.deleteApiKey(providerId);
+            await this.providerOAuthTokenStore.delete(providerId);
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
             return { success: true };
         });
@@ -64,19 +171,28 @@ export class ProviderHandler {
                 processLog(`[ProviderHandler] getActiveProvider failed: ${error instanceof Error ? error.message : String(error)}`);
                 return '';
             });
-            const providers = await Promise.all(definitions.map(async (def) => ({
-                apiKeyUrl: def.apiKeyUrl,
-                category: def.category,
-                description: def.description,
-                id: def.id,
-                isConnected: await this.providerConfigStore.isProviderConnected(def.id).catch((error) => {
-                    processLog(`[ProviderHandler] isProviderConnected failed for ${def.id}: ${error instanceof Error ? error.message : String(error)}`);
-                    return false;
-                }),
-                isCurrent: def.id === activeProviderId,
-                name: def.name,
-                requiresApiKey: providerRequiresApiKey(def.id),
-            })));
+            const config = await this.providerConfigStore.read().catch(() => null);
+            const providers = await Promise.all(definitions.map(async (def) => {
+                const providerConfig = config?.providers[def.id];
+                const authMethod = providerConfig?.authMethod;
+                return {
+                    apiKeyUrl: def.apiKeyUrl,
+                    authMethod,
+                    category: def.category,
+                    description: def.description,
+                    id: def.id,
+                    isConnected: await this.providerConfigStore.isProviderConnected(def.id).catch((error) => {
+                        processLog(`[ProviderHandler] isProviderConnected failed for ${def.id}: ${error instanceof Error ? error.message : String(error)}`);
+                        return false;
+                    }),
+                    isCurrent: def.id === activeProviderId,
+                    name: def.name,
+                    oauthCallbackMode: def.oauth?.callbackMode,
+                    oauthLabel: def.oauth?.modes[0]?.label,
+                    requiresApiKey: providerRequiresApiKey(def.id, authMethod),
+                    supportsOAuth: Boolean(def.oauth),
+                };
+            }));
             return { providers };
         });
     }
@@ -87,6 +203,92 @@ export class ProviderHandler {
             return { success: true };
         });
     }
+    /* eslint-disable camelcase -- OAuth query params follow RFC 6749 naming */
+    setupStartOAuth() {
+        this.transport.onRequest(ProviderEvents.START_OAUTH, async (data, clientId) => {
+            const providerDef = getProviderById(data.providerId);
+            if (!providerDef?.oauth) {
+                const errorResponse = {
+                    authUrl: '',
+                    callbackMode: 'auto',
+                    error: 'Provider does not support OAuth',
+                    success: false,
+                };
+                return errorResponse;
+            }
+            try {
+                const oauthConfig = providerDef.oauth;
+                // Clean up any existing flow for this provider (race condition guard)
+                const existingFlow = this.oauthFlows.get(data.providerId);
+                if (existingFlow?.callbackServer) {
+                    await existingFlow.callbackServer.stop().catch(() => { });
+                }
+                this.oauthFlows.delete(data.providerId);
+                // Generate PKCE parameters
+                const pkce = this.generatePkce();
+                // Build auth URL
+                const mode = oauthConfig.modes.find((m) => m.id === (data.mode ?? 'default')) ?? oauthConfig.modes[0];
+                const params = new URLSearchParams({
+                    client_id: oauthConfig.clientId,
+                    code_challenge: pkce.codeChallenge,
+                    code_challenge_method: 'S256',
+                    redirect_uri: oauthConfig.redirectUri,
+                    response_type: 'code',
+                    scope: oauthConfig.scopes,
+                    state: pkce.state,
+                });
+                // Provider-specific extra params (e.g. OpenAI's codex_cli_simplified_flow)
+                if (oauthConfig.extraParams) {
+                    for (const [key, value] of Object.entries(oauthConfig.extraParams)) {
+                        params.set(key, value);
+                    }
+                }
+                const authUrl = `${mode.authUrl}?${params.toString()}`;
+                // Start callback server for auto mode
+                let callbackServer;
+                if (oauthConfig.callbackMode === 'auto' && oauthConfig.callbackPort) {
+                    callbackServer = this.createCallbackServer({ port: oauthConfig.callbackPort });
+                    await callbackServer.start();
+                }
+                // Store flow state
+                this.oauthFlows.set(data.providerId, {
+                    callbackServer,
+                    clientId,
+                    codeVerifier: pkce.codeVerifier,
+                    state: pkce.state,
+                });
+                // Open browser (non-fatal on failure)
+                try {
+                    await this.browserLauncher.open(authUrl);
+                }
+                catch {
+                    processLog(`[ProviderHandler] Browser launch failed for OAuth — user can copy the URL`);
+                }
+                return { authUrl, callbackMode: oauthConfig.callbackMode, success: true };
+            }
+            catch (error) {
+                // Clean up callback server if it was started but flow setup failed
+                const partialFlow = this.oauthFlows.get(data.providerId);
+                if (partialFlow?.callbackServer) {
+                    await partialFlow.callbackServer.stop().catch(() => { });
+                }
+                this.oauthFlows.delete(data.providerId);
+                const errorResponse = {
+                    authUrl: '',
+                    callbackMode: 'auto',
+                    error: getErrorMessage(error),
+                    success: false,
+                };
+                return errorResponse;
+            }
+        });
+    }
+    /* eslint-enable camelcase */
+    setupSubmitOAuthCode() {
+        this.transport.onRequest(ProviderEvents.SUBMIT_OAUTH_CODE, 
+        // Stub for M2 (Anthropic code-paste flow)
+        async () => ({ error: 'Code submission is not yet supported for this provider', success: false }));
+    }
     setupValidateApiKey() {
         this.transport.onRequest(ProviderEvents.VALIDATE_API_KEY, async (data) => {
             try {

package/dist/server/templates/skill/SKILL.md

@@ -93,7 +93,25 @@ brv providers list
 brv providers connect openai --api-key sk-xxx --model gpt-4.1
 ```
 
-### 4. Cloud Sync (Optional)
+### 4. Project Locations
+**Overview:** List registered projects and their context tree paths. Returns project metadata including initialization status and active state. Use `-f json` for machine-readable output.
+
+**Use this when:**
+- You need to find a project's context tree path
+- You need to check which projects are registered
+- You need to verify if a project is initialized
+
+**Do NOT use this when:**
+- You already know the project path from your current context
+- You need project content rather than metadata — use `brv query` instead
+
+```bash
+brv locations -f json
+```
+
+JSON fields: `projectPath`, `contextTreePath`, `isCurrent`, `isActive`, `isInitialized`.
+
+### 5. Cloud Sync (Optional)
 **Overview:** Sync your local knowledge with a team via ByteRover's cloud service. Requires ByteRover authentication.
 
 **Setup steps:**

package/dist/shared/constants/oauth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ChatGPT OAuth (Codex) API base URL — single source of truth.
+ * Used by the agent's OpenAI provider module and the server's provider config resolver.
+ */
+export declare const CHATGPT_OAUTH_BASE_URL = "https://chatgpt.com/backend-api/codex";
+/**
+ * Originator header/param value sent to OpenAI in OAuth flows.
+ */
+export declare const CHATGPT_OAUTH_ORIGINATOR = "byterover";
+/**
+ * OAuth callback timeout in milliseconds (5 minutes).
+ * Used by the callback server, TUI await-oauth-callback mutation, and CLI connect command.
+ */
+export declare const OAUTH_CALLBACK_TIMEOUT_MS = 300000;

package/dist/shared/constants/oauth.js

@@ -0,0 +1,14 @@
+/**
+ * ChatGPT OAuth (Codex) API base URL — single source of truth.
+ * Used by the agent's OpenAI provider module and the server's provider config resolver.
+ */
+export const CHATGPT_OAUTH_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+/**
+ * Originator header/param value sent to OpenAI in OAuth flows.
+ */
+export const CHATGPT_OAUTH_ORIGINATOR = 'byterover';
+/**
+ * OAuth callback timeout in milliseconds (5 minutes).
+ * Used by the callback server, TUI await-oauth-callback mutation, and CLI connect command.
+ */
+export const OAUTH_CALLBACK_TIMEOUT_MS = 300_000;

package/dist/shared/transport/events/index.d.ts

@@ -6,6 +6,7 @@ export * from './connector-events.js';
 export * from './hub-events.js';
 export * from './init-events.js';
 export * from './llm-events.js';
+export * from './locations-events.js';
 export * from './model-events.js';
 export * from './onboarding-events.js';
 export * from './provider-events.js';
@@ -85,11 +86,16 @@ export declare const AllEventGroups: readonly [{
     readonly COMPLETE: "onboarding:complete";
     readonly GET_STATE: "onboarding:getState";
 }, {
+    readonly AWAIT_OAUTH_CALLBACK: "provider:awaitOAuthCallback";
+    readonly CANCEL_OAUTH: "provider:cancelOAuth";
     readonly CONNECT: "provider:connect";
     readonly DISCONNECT: "provider:disconnect";
     readonly GET_ACTIVE: "provider:getActive";
     readonly LIST: "provider:list";
     readonly SET_ACTIVE: "provider:setActive";
+    readonly START_OAUTH: "provider:startOAuth";
+    readonly SUBMIT_OAUTH_CODE: "provider:submitOAuthCode";
+    readonly UPDATED: "provider:updated";
     readonly VALIDATE_API_KEY: "provider:validateApiKey";
 }, {
     readonly EXECUTE: "pull:execute";
@@ -103,6 +109,8 @@ export declare const AllEventGroups: readonly [{
     readonly EXECUTE: "reset:execute";
 }, {
     readonly SWITCHED: "session:switched";
+}, {
+    readonly GET: "locations:get";
 }, {
     readonly LIST: "space:list";
     readonly SWITCH: "space:switch";

package/dist/shared/transport/events/index.js

@@ -8,6 +8,7 @@ export * from './connector-events.js';
 export * from './hub-events.js';
 export * from './init-events.js';
 export * from './llm-events.js';
+export * from './locations-events.js';
 export * from './model-events.js';
 export * from './onboarding-events.js';
 export * from './provider-events.js';
@@ -26,6 +27,7 @@ import { ConnectorEvents } from './connector-events.js';
 import { HubEvents } from './hub-events.js';
 import { InitEvents } from './init-events.js';
 import { LlmEvents } from './llm-events.js';
+import { LocationsEvents } from './locations-events.js';
 import { ModelEvents } from './model-events.js';
 import { OnboardingEvents } from './onboarding-events.js';
 import { ProviderEvents } from './provider-events.js';
@@ -55,6 +57,7 @@ export const AllEventGroups = [
     PushEvents,
     ResetEvents,
     SessionEvents,
+    LocationsEvents,
     SpaceEvents,
     StatusEvents,
     TaskEvents,

package/dist/shared/transport/events/locations-events.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectLocationDTO } from '../types/dto.js';
+export declare const LocationsEvents: {
+    readonly GET: "locations:get";
+};
+export interface LocationsGetResponse {
+    locations: ProjectLocationDTO[];
+}

package/dist/shared/transport/events/locations-events.js

@@ -0,0 +1,3 @@
+export const LocationsEvents = {
+    GET: 'locations:get',
+};

package/dist/shared/transport/events/model-events.d.ts

@@ -9,6 +9,7 @@ export interface ModelListRequest {
 }
 export interface ModelListResponse {
     activeModel?: string;
+    error?: string;
     favorites: string[];
     models: ModelDTO[];
     recent: string[];
@@ -26,5 +27,6 @@ export interface ModelSetActiveRequest {
     providerId: string;
 }
 export interface ModelSetActiveResponse {
+    error?: string;
     success: boolean;
 }

package/dist/shared/transport/events/provider-events.d.ts

@@ -1,10 +1,15 @@
 import type { ProviderDTO } from '../types/dto.js';
 export declare const ProviderEvents: {
+    readonly AWAIT_OAUTH_CALLBACK: "provider:awaitOAuthCallback";
+    readonly CANCEL_OAUTH: "provider:cancelOAuth";
     readonly CONNECT: "provider:connect";
     readonly DISCONNECT: "provider:disconnect";
     readonly GET_ACTIVE: "provider:getActive";
     readonly LIST: "provider:list";
     readonly SET_ACTIVE: "provider:setActive";
+    readonly START_OAUTH: "provider:startOAuth";
+    readonly SUBMIT_OAUTH_CODE: "provider:submitOAuthCode";
+    readonly UPDATED: "provider:updated";
     readonly VALIDATE_API_KEY: "provider:validateApiKey";
 };
 export interface ProviderListResponse {
@@ -42,3 +47,34 @@ export interface ProviderSetActiveRequest {
 export interface ProviderSetActiveResponse {
     success: boolean;
 }
+export interface ProviderCancelOAuthRequest {
+    providerId: string;
+}
+export interface ProviderCancelOAuthResponse {
+    success: boolean;
+}
+export interface ProviderStartOAuthRequest {
+    mode?: string;
+    providerId: string;
+}
+export interface ProviderStartOAuthResponse {
+    authUrl: string;
+    callbackMode: 'auto' | 'code-paste';
+    error?: string;
+    success: boolean;
+}
+export interface ProviderAwaitOAuthCallbackRequest {
+    providerId: string;
+}
+export interface ProviderAwaitOAuthCallbackResponse {
+    error?: string;
+    success: boolean;
+}
+export interface ProviderSubmitOAuthCodeRequest {
+    code: string;
+    providerId: string;
+}
+export interface ProviderSubmitOAuthCodeResponse {
+    error?: string;
+    success: boolean;
+}

package/dist/shared/transport/events/provider-events.js

@@ -1,8 +1,13 @@
 export const ProviderEvents = {
+    AWAIT_OAUTH_CALLBACK: 'provider:awaitOAuthCallback',
+    CANCEL_OAUTH: 'provider:cancelOAuth',
     CONNECT: 'provider:connect',
     DISCONNECT: 'provider:disconnect',
     GET_ACTIVE: 'provider:getActive',
     LIST: 'provider:list',
     SET_ACTIVE: 'provider:setActive',
+    START_OAUTH: 'provider:startOAuth',
+    SUBMIT_OAUTH_CODE: 'provider:submitOAuthCode',
+    UPDATED: 'provider:updated',
     VALIDATE_API_KEY: 'provider:validateApiKey',
 };

package/dist/shared/transport/types/dto.d.ts

@@ -49,13 +49,17 @@ export interface ConnectorDTO {
 }
 export interface ProviderDTO {
     apiKeyUrl?: string;
+    authMethod?: 'api-key' | 'oauth';
     category: 'other' | 'popular';
     description: string;
     id: string;
     isConnected: boolean;
     isCurrent: boolean;
     name: string;
+    oauthCallbackMode?: 'auto' | 'code-paste';
+    oauthLabel?: string;
     requiresApiKey: boolean;
+    supportsOAuth: boolean;
 }
 export interface ModelDTO {
     contextLength: number;
@@ -97,6 +101,17 @@ export interface HubEntryDTO {
     type: 'agent-skill' | 'bundle';
     version: string;
 }
+export interface ProjectLocationDTO {
+    /** Absolute path to the context tree directory (e.g., '/Users/foo/project/.brv/context-tree') */
+    contextTreePath: string;
+    /** True if this project has connected clients/agents or is the current project */
+    isActive: boolean;
+    /** True if this is the project the client is currently running from */
+    isCurrent: boolean;
+    /** True if .brv/context-tree exists */
+    isInitialized: boolean;
+    projectPath: string;
+}
 export interface StatusDTO {
     authStatus: 'expired' | 'logged_in' | 'not_logged_in' | 'unknown';
     contextTreeChanges?: ContextTreeChanges;

package/dist/tui/features/commands/definitions/index.js

@@ -2,6 +2,7 @@ import { connectorsCommand } from './connectors.js';
 import { curateCommand } from './curate.js';
 import { exitCommand } from './exit.js';
 import { hubCommand } from './hub.js';
+import { locationsCommand } from './locations.js';
 import { loginCommand } from './login.js';
 import { logoutCommand } from './logout.js';
 import { modelCommand } from './model.js';
@@ -22,6 +23,7 @@ import { statusCommand } from './status.js';
 export const load = () => [
     // Core workflow - most frequently used
     statusCommand,
+    locationsCommand,
     curateCommand,
     queryCommand,
     // Connectors management

package/dist/tui/features/commands/definitions/locations.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const locationsCommand: SlashCommand;

package/dist/tui/features/commands/definitions/locations.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { LocationsView } from '../../locations/components/locations-view.js';
+export const locationsCommand = {
+    action() {
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(LocationsView, { onCancel, onComplete }),
+        };
+    },
+    description: 'List all registered projects and their context tree status',
+    name: 'locations',
+};

package/dist/tui/features/locations/api/get-locations.d.ts

@@ -0,0 +1,16 @@
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type LocationsGetResponse } from '../../../../shared/transport/events/index.js';
+export declare const getLocations: () => Promise<LocationsGetResponse>;
+export declare const getLocationsQueryOptions: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<LocationsGetResponse, Error, LocationsGetResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<LocationsGetResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: LocationsGetResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetLocationsOptions = {
+    queryConfig?: QueryConfig<typeof getLocationsQueryOptions>;
+};
+export declare const useGetLocations: ({ queryConfig }?: UseGetLocationsOptions) => import("@tanstack/react-query").UseQueryResult<LocationsGetResponse, Error>;
+export {};

package/dist/tui/features/locations/api/get-locations.js

@@ -0,0 +1,17 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { LocationsEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const getLocations = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(LocationsEvents.GET);
+};
+export const getLocationsQueryOptions = () => queryOptions({
+    queryFn: getLocations,
+    queryKey: ['locations'],
+});
+export const useGetLocations = ({ queryConfig } = {}) => useQuery({
+    ...getLocationsQueryOptions(),
+    ...queryConfig,
+});

package/dist/tui/features/locations/components/locations-view.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+export declare function LocationsView({ onCancel, onComplete }: CustomDialogCallbacks): React.ReactNode;

package/dist/tui/features/locations/components/locations-view.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect } from 'react';
+import { useGetLocations } from '../api/get-locations.js';
+import { formatLocations } from '../utils/format-locations.js';
+export function LocationsView({ onCancel, onComplete }) {
+    const { data, error, isLoading } = useGetLocations();
+    useInput((_input, key) => {
+        if (key.escape)
+            onCancel();
+    });
+    useEffect(() => {
+        if (data) {
+            onComplete(formatLocations(data.locations));
+        }
+        if (error) {
+            onComplete(`Failed to get locations: ${error.message}`);
+        }
+    }, [data, error, onComplete]);
+    if (isLoading) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Loading locations..."] }));
+    }
+    return null;
+}

package/dist/tui/features/locations/utils/format-locations.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectLocationDTO } from '../../../../shared/transport/types/dto.js';
+export declare function formatLocations(locations: ProjectLocationDTO[]): string;

package/dist/tui/features/locations/utils/format-locations.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+function formatLocationEntry(loc) {
+    const label = loc.isCurrent ? '  ' + chalk.green('[current]') : loc.isActive ? '  ' + chalk.yellow('[active]') : '';
+    const path = loc.isCurrent || loc.isActive ? chalk.bold(loc.projectPath) : loc.projectPath;
+    const lines = [`  ${path}${label}`];
+    if (loc.isInitialized) {
+        lines.push(chalk.dim('  └─ .brv/context-tree/'));
+    }
+    else {
+        lines.push(chalk.dim('  └─ .brv/context-tree/    (not initialized)'));
+    }
+    return lines;
+}
+export function formatLocations(locations) {
+    const lines = [];
+    if (locations.length > 0) {
+        lines.push(`Registered Projects — ${locations.length} found`, chalk.dim('──────────────────────────────────────────'));
+        for (const loc of locations) {
+            lines.push(...formatLocationEntry(loc), '');
+        }
+    }
+    else {
+        lines.push('Registered Projects — none found');
+    }
+    return lines.join('\n');
+}