orquesta-cli 0.1.21 → 0.1.23

package/dist/cli.js

@@ -30,6 +30,7 @@ program
     .option('--debug', 'Enable debug logging')
     .option('--llm-log', 'Enable LLM logging')
     .option('--eval', 'Evaluation mode: read JSON from stdin, output NDJSON events')
+    .option('--login', 'Sign in to Orquesta via browser (no token paste required)')
     .option('--token <token>', 'Connect to Orquesta dashboard with CLI token')
     .option('--project <projectId>', 'Select project ID when connecting with token')
     .option('--switch-project [projectId]', 'Switch to a different project')
@@ -67,6 +68,14 @@ program
         const success = await switchProject(projectId);
         process.exit(success ? 0 : 1);
     }
+    if (options.login) {
+        const { browserLogin } = await import('./setup/browser-login.js');
+        const result = await browserLogin();
+        if (!result.success) {
+            console.error(chalk.red(result.error || 'Login failed'));
+            process.exit(1);
+        }
+    }
     if (options.token) {
         const result = await connectWithToken(options.token, options.project);
         if (!result.connected) {

package/dist/core/llm/llm-client.js

@@ -5,6 +5,13 @@ import { NetworkError, APIError, TimeoutError, ConnectionError, } from '../../er
 import { LLMError, TokenLimitError, RateLimitError, ContextLengthError, } from '../../errors/llm.js';
 import { logger, isLLMLogEnabled } from '../../utils/logger.js';
 import { usageTracker } from '../usage-tracker.js';
+import { getForcedTier } from '../routing-state.js';
+function buildPerRequestHeaders() {
+    const tier = getForcedTier();
+    if (!tier)
+        return undefined;
+    return { 'X-Batuta-Force-Tier': tier };
+}
 export class LLMClient {
     axiosInstance;
     baseUrl;
@@ -111,6 +118,7 @@ export class LLMClient {
             this.currentAbortController = new AbortController();
             const response = await this.axiosInstance.post(url, requestBody, {
                 signal: this.currentAbortController.signal,
+                headers: buildPerRequestHeaders(),
             });
             this.currentAbortController = null;
             const elapsed = logger.endTimer('llm-api-call');
@@ -270,6 +278,7 @@ export class LLMClient {
             const response = await this.axiosInstance.post(url, requestBody, {
                 responseType: 'stream',
                 signal: this.currentAbortController.signal,
+                headers: buildPerRequestHeaders(),
             });
             logger.debug('Streaming response started', { status: response.status });
             const stream = response.data;

package/dist/core/routing-state.d.ts

@@ -0,0 +1,4 @@
+export type ForcedTier = 'fast' | 'balanced' | 'premium' | null;
+export declare function getForcedTier(): ForcedTier;
+export declare function setForcedTier(tier: ForcedTier): void;
+//# sourceMappingURL=routing-state.d.ts.map

package/dist/core/routing-state.js

@@ -0,0 +1,8 @@
+let forcedTier = null;
+export function getForcedTier() {
+    return forcedTier;
+}
+export function setForcedTier(tier) {
+    forcedTier = tier;
+}
+//# sourceMappingURL=routing-state.js.map

package/dist/core/slash-command-handler.js

@@ -3,6 +3,7 @@ import { usageTracker } from './usage-tracker.js';
 import { logger } from '../utils/logger.js';
 import { fullSync } from '../orquesta/config-sync.js';
 import { configManager } from './config/config-manager.js';
+import { getForcedTier, setForcedTier } from './routing-state.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
@@ -131,6 +132,42 @@ export async function executeSlashCommand(command, context) {
             },
         };
     }
+    if (trimmedCommand === '/route' || trimmedCommand.startsWith('/route ')) {
+        const arg = trimmedCommand.slice('/route'.length).trim().toLowerCase();
+        const currentModel = configManager.getCurrentModel();
+        const currentModelId = currentModel?.id ?? null;
+        const onBatutaAuto = currentModelId === 'batuta-auto';
+        let body;
+        if (!arg) {
+            const pinned = getForcedTier();
+            body = pinned
+                ? `Batuta Auto tier pinned to: ${pinned}.\n\nUse /route auto to let the classifier decide again.`
+                : `Batuta Auto: classifier-driven (default).\n\nUsage: /route [auto|fast|balanced|premium]\n  fast      → Haiku 4.5 (cheapest, simple Q&A)\n  balanced  → Sonnet 4.6 (code, day-to-day)\n  premium   → Opus 4.7 (reasoning, long context)\n  auto      → let the classifier decide per prompt`;
+        }
+        else if (arg === 'auto' || arg === 'reset' || arg === 'clear') {
+            setForcedTier(null);
+            body = `Batuta Auto: pin cleared. Classifier will choose tier per prompt.`;
+        }
+        else if (arg === 'fast' || arg === 'balanced' || arg === 'premium') {
+            setForcedTier(arg);
+            body = onBatutaAuto
+                ? `Batuta Auto: pinned to ${arg}. Every prompt this session routes to ${arg === 'fast' ? 'Haiku 4.5' : arg === 'balanced' ? 'Sonnet 4.6' : 'Opus 4.7'}.`
+                : `Pin set to ${arg}, but the active model is "${currentModelId ?? 'none'}", not "batuta-auto" — the pin only takes effect when you switch to batuta-auto (use /model).`;
+        }
+        else {
+            body = `Unknown tier: "${arg}". Use one of: auto, fast, balanced, premium.`;
+        }
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: body },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
     if (trimmedCommand === '/usage') {
         const usageMessage = usageTracker.formatUsageDisplay();
         const updatedMessages = [
@@ -276,6 +313,7 @@ Available commands:
   /tool           - Enable/disable optional tools (Browser, Background)
   /load           - Load a saved session
   /usage          - Show token usage statistics
+  /route          - Pin Batuta Auto tier (fast/balanced/premium/auto)
   /sync           - Bidirectional sync with Orquesta dashboard (pull & push LLM configs)
 
 CLI Options (restart required):

package/dist/setup/browser-login.d.ts

@@ -0,0 +1,5 @@
+export declare function browserLogin(): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+//# sourceMappingURL=browser-login.d.ts.map

package/dist/setup/browser-login.js

@@ -0,0 +1,90 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import chalk from 'chalk';
+import { configManager } from '../core/config/config-manager.js';
+import { syncOrquestaConfigs } from '../orquesta/config-sync.js';
+import { logger } from '../utils/logger.js';
+const ORQUESTA_API = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
+const WS_URL = process.env['ORQUESTA_WS_URL']?.replace(/^wss?:\/\//, 'https://') || 'https://ws.orquesta.live';
+const POLL_INTERVAL_MS = 2000;
+const TIMEOUT_MS = 5 * 60 * 1000;
+function openBrowser(url) {
+    const opener = process.platform === 'darwin' ? 'open' :
+        process.platform === 'win32' ? 'start' :
+            'xdg-open';
+    try {
+        const child = spawn(opener, [url], { detached: true, stdio: 'ignore', shell: process.platform === 'win32' });
+        child.unref();
+        return true;
+    }
+    catch (err) {
+        logger.debug('Failed to open browser', { err });
+        return false;
+    }
+}
+async function pollOnce(sessionId) {
+    try {
+        const res = await fetch(`${WS_URL}/auth/result/${sessionId}`);
+        if (res.status !== 200)
+            return null;
+        const data = await res.json();
+        if (!data.token || !data.organizationId)
+            return null;
+        return {
+            token: data.token,
+            organizationId: data.organizationId,
+            organizationName: data.organizationName || 'Unknown',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function browserLogin() {
+    const sessionId = randomUUID();
+    const url = `${ORQUESTA_API}/cli/auth?session=${sessionId}`;
+    console.log();
+    console.log(chalk.cyan('Logging in to Orquesta…'));
+    console.log();
+    const opened = openBrowser(url);
+    if (opened) {
+        console.log(chalk.dim('Opened your browser. If nothing happened, copy this URL:'));
+    }
+    else {
+        console.log(chalk.yellow('Could not open a browser automatically. Open this URL on any device:'));
+    }
+    console.log('  ' + chalk.cyan(url));
+    console.log();
+    console.log(chalk.dim('Waiting for authorization…'));
+    const deadline = Date.now() + TIMEOUT_MS;
+    await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+    while (Date.now() < deadline) {
+        const hit = await pollOnce(sessionId);
+        if (hit) {
+            await configManager.setOrquestaConfig({
+                token: hit.token,
+                organizationId: hit.organizationId,
+                organizationName: hit.organizationName,
+                projectId: undefined,
+                projectName: undefined,
+                autoSync: true,
+                connectedAt: new Date().toISOString(),
+            });
+            console.log();
+            console.log(chalk.green(`✓ Logged in as ${hit.organizationName}`));
+            try {
+                const sync = await syncOrquestaConfigs();
+                if (sync.success) {
+                    console.log(chalk.dim(`  Synced ${sync.added + sync.updated} endpoint(s) from the dashboard.`));
+                }
+            }
+            catch (err) {
+                logger.debug('Initial sync after login failed', { err });
+            }
+            return { success: true };
+        }
+        await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    return { success: false, error: 'Timed out waiting for authorization (5 min).' };
+}
+//# sourceMappingURL=browser-login.js.map

package/dist/ui/TodoPanel.d.ts

@@ -9,6 +9,10 @@ export declare const TodoPanel: React.FC<TodoPanelProps>;
 export declare const TodoStatusBar: React.FC<{
     todos: TodoItem[];
     projectName?: string;
+    batutaUsage?: {
+        tokensUsed: number;
+        tokenLimit: number;
+    } | null;
 }>;
 export default TodoPanel;
 //# sourceMappingURL=TodoPanel.d.ts.map

package/dist/ui/TodoPanel.js

@@ -100,12 +100,31 @@ export const TodoPanel = React.memo(({ todos, currentTodoId, isProcessing = fals
     }
     return true;
 });
-export const TodoStatusBar = React.memo(({ todos, projectName }) => {
+export const TodoStatusBar = React.memo(({ todos, projectName, batutaUsage }) => {
     useEffect(() => {
         logger.debug('TodoStatusBar rendered', { todoCount: todos.length });
     }, [todos.length]);
+    const batutaIndicator = batutaUsage && batutaUsage.tokenLimit > 0 ? (() => {
+        const pct = (batutaUsage.tokensUsed / batutaUsage.tokenLimit) * 100;
+        const color = pct > 90 ? 'red' : pct > 70 ? 'yellow' : 'greenBright';
+        const fmt = (n) => n < 1000 ? `${n}` : n < 1_000_000 ? `${(n / 1000).toFixed(1)}k` : `${(n / 1_000_000).toFixed(2)}M`;
+        return (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "gray" }, "Batuta "),
+            React.createElement(Text, { color: color },
+                fmt(batutaUsage.tokensUsed),
+                "/",
+                fmt(batutaUsage.tokenLimit))));
+    })() : null;
     if (todos.length === 0) {
-        return null;
+        if (!batutaIndicator)
+            return null;
+        return (React.createElement(Box, null,
+            projectName && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "magenta" },
+                    "\uD83D\uDCC1 ",
+                    projectName),
+                React.createElement(Text, { color: "white" }, " \u2502 "))),
+            batutaIndicator));
     }
     const completedCount = todos.filter(t => t.status === 'completed').length;
     const inProgressCount = todos.filter(t => t.status === 'in_progress').length;
@@ -134,7 +153,10 @@ export const TodoStatusBar = React.memo(({ todos, projectName }) => {
                 currentTodo.title.length > 30 ? '...' : ''))),
         inProgressCount === 0 && completedCount === todos.length && (React.createElement(React.Fragment, null,
             React.createElement(Text, { color: "white" }, " \u2502 "),
-            React.createElement(Text, { color: "greenBright" }, "Done")))));
+            React.createElement(Text, { color: "greenBright" }, "Done"))),
+        batutaIndicator && (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "white" }, " \u2502 "),
+            batutaIndicator))));
 });
 export default TodoPanel;
 //# sourceMappingURL=TodoPanel.js.map

package/dist/ui/components/PlanExecuteApp.js

@@ -8,6 +8,7 @@ import { getShellConfig, isNativeWindows } from '../../utils/platform-utils.js';
 import { CustomTextInput } from './CustomTextInput.js';
 import { LLMClient, createLLMClient } from '../../core/llm/llm-client.js';
 import { TodoPanel, TodoStatusBar } from '../TodoPanel.js';
+import { useBatutaUsage } from '../hooks/useBatutaUsage.js';
 import { sessionManager } from '../../core/session/session-manager.js';
 import { initializeDocsDirectory, setDocsSearchProgressCallback } from '../../agents/docs-search/index.js';
 import { DocsSearchProgress } from './DocsSearchProgress.js';
@@ -96,6 +97,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     const [subActivities, setSubActivities] = useState([]);
     const [sessionTokens, setSessionTokens] = useState(0);
     const [sessionElapsed, setSessionElapsed] = useState(0);
+    const batutaUsage = useBatutaUsage();
     const [currentToolName, setCurrentToolName] = useState(null);
     const [showSessionBrowser, setShowSessionBrowser] = useState(false);
     const [showSettings, setShowSettings] = useState(false);
@@ -1339,9 +1341,9 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
                 React.createElement(Text, { color: "cyan" }, currentModelInfo.model),
                 React.createElement(Text, { color: "gray" }, " \u2502 "),
                 React.createElement(Text, { color: "gray" }, shortenPath(process.cwd())),
-                planExecutionState.todos.length > 0 && (React.createElement(React.Fragment, null,
+                (planExecutionState.todos.length > 0 || batutaUsage) && (React.createElement(React.Fragment, null,
                     React.createElement(Text, { color: "gray" }, " \u2502 "),
-                    React.createElement(TodoStatusBar, { todos: planExecutionState.todos, projectName: configManager.getOrquestaConfig()?.projectName })))),
+                    React.createElement(TodoStatusBar, { todos: planExecutionState.todos, projectName: configManager.getOrquestaConfig()?.projectName, batutaUsage: batutaUsage })))),
             React.createElement(Text, { color: "gray", dimColor: true }, "Tab: mode \u2502 /help")))),
         showLogFiles && (React.createElement(Box, { marginTop: 0 },
             React.createElement(LogBrowser, { onClose: () => setShowLogFiles(false) })))));

package/dist/ui/components/StatusBar.d.ts

@@ -19,6 +19,11 @@ export interface StatusBarProps {
     healthStatus?: 'healthy' | 'unhealthy' | 'checking' | 'unknown';
     currentActivity?: string;
     sessionElapsedSeconds?: number;
+    batutaUsage?: {
+        tokensUsed: number;
+        tokenLimit: number;
+        tier: 'llm' | 'llm_team' | null;
+    } | null;
 }
 export declare const StatusBar: React.FC<StatusBarProps>;
 export default StatusBar;

package/dist/ui/components/StatusBar.js

@@ -62,7 +62,7 @@ function formatElapsedTime(seconds) {
     const secs = seconds % 60;
     return `${mins}m ${secs}s`;
 }
-export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizationName: _organizationName, workingDirectory, status = 'idle', message: _message, messageCount = 0, sessionTokens = 0, contextUsage, contextRemainingPercent, todoCount, todoCompleted, healthStatus, currentActivity, sessionElapsedSeconds, }) => {
+export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizationName: _organizationName, workingDirectory, status = 'idle', message: _message, messageCount = 0, sessionTokens = 0, contextUsage, contextRemainingPercent, todoCount, todoCompleted, healthStatus, currentActivity, sessionElapsedSeconds, batutaUsage, }) => {
     void _endpoint;
     void _message;
     useEffect(() => {
@@ -149,6 +149,16 @@ export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizatio
                 React.createElement(Text, { color: "cyan" },
                     "\u26A1 ",
                     formatTokens(sessionTokens)))),
+            batutaUsage && batutaUsage.tokenLimit > 0 && (() => {
+                const pct = (batutaUsage.tokensUsed / batutaUsage.tokenLimit) * 100;
+                const color = pct > 90 ? 'red' : pct > 70 ? 'yellow' : 'green';
+                return (React.createElement(Box, { marginRight: 2 },
+                    React.createElement(Text, { color: "gray" }, "Batuta "),
+                    React.createElement(Text, { color: color },
+                        formatTokens(batutaUsage.tokensUsed),
+                        "/",
+                        formatTokens(batutaUsage.tokenLimit))));
+            })(),
             contextUsage && contextUsage.current > 0 && (React.createElement(Box, { marginRight: 2 },
                 React.createElement(Text, { color: "gray" }, "CTX "),
                 React.createElement(ContextMiniBar, { current: contextUsage.current, max: contextUsage.max }))),

package/dist/ui/hooks/useBatutaUsage.d.ts

@@ -0,0 +1,8 @@
+export interface BatutaUsage {
+    tokensUsed: number;
+    tokenLimit: number;
+    tier: 'llm' | 'llm_team' | null;
+    enabled: boolean;
+}
+export declare function useBatutaUsage(): BatutaUsage | null;
+//# sourceMappingURL=useBatutaUsage.d.ts.map

package/dist/ui/hooks/useBatutaUsage.js

@@ -0,0 +1,46 @@
+import { useState, useEffect } from 'react';
+import { configManager } from '../../core/config/config-manager.js';
+const ORQUESTA_API = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
+const POLL_INTERVAL_MS = 60_000;
+export function useBatutaUsage() {
+    const [usage, setUsage] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        async function tick() {
+            const endpoint = configManager.getCurrentEndpoint();
+            const orquestaConfig = configManager.getOrquestaConfig();
+            const onBatuta = endpoint?.provider === 'batuta' || endpoint?.id === 'batuta-proxy';
+            if (!onBatuta || !orquestaConfig?.token) {
+                if (!cancelled)
+                    setUsage(null);
+                return;
+            }
+            try {
+                const res = await fetch(`${ORQUESTA_API}/api/billing`, {
+                    headers: { Authorization: `Bearer ${orquestaConfig.token}` },
+                });
+                if (!res.ok || cancelled)
+                    return;
+                const data = await res.json();
+                if (data.batutaLlm && !cancelled) {
+                    setUsage({
+                        tokensUsed: data.batutaLlm.tokensUsed ?? 0,
+                        tokenLimit: data.batutaLlm.tokenLimit ?? 0,
+                        tier: data.batutaLlm.tier ?? null,
+                        enabled: data.batutaLlm.enabled ?? false,
+                    });
+                }
+            }
+            catch {
+            }
+        }
+        tick();
+        const interval = setInterval(tick, POLL_INTERVAL_MS);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, []);
+    return usage;
+}
+//# sourceMappingURL=useBatutaUsage.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",