orquesta-cli 0.1.13 → 0.1.15

package/dist/orquesta/config-sync.js

@@ -0,0 +1,230 @@
+import { configManager } from '../core/config/config-manager.js';
+import { logger } from '../utils/logger.js';
+const ORQUESTA_API = process.env['ORQUESTA_API_URL'] || 'https://orquesta.live';
+export async function fetchOrquestaProjects(token) {
+    try {
+        const response = await fetch(`${ORQUESTA_API}/api/orquesta-cli/projects`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+export async function validateOrquestaToken(token) {
+    try {
+        const response = await fetch(`${ORQUESTA_API}/api/agent/validate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                token,
+                agentInfo: {
+                    hostname: (await import('os')).hostname(),
+                    os: `${(await import('os')).type()} ${(await import('os')).release()}`,
+                    platform: (await import('os')).platform(),
+                    type: 'orquesta-cli',
+                    workingDirectory: process.cwd(),
+                },
+            }),
+        });
+        const data = (await response.json());
+        if (!response.ok || !data.valid) {
+            return {
+                valid: false,
+                error: data.error || 'Invalid token',
+            };
+        }
+        return data;
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : 'Network error',
+        };
+    }
+}
+export async function syncOrquestaConfigs() {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        return {
+            success: false,
+            added: 0,
+            updated: 0,
+            unchanged: 0,
+            error: 'Not connected to Orquesta',
+        };
+    }
+    try {
+        logger.flow('Fetching configs from Orquesta');
+        const response = await fetch(`${ORQUESTA_API}/api/orquesta-cli/endpoints`, {
+            headers: {
+                Authorization: `Bearer ${orquestaConfig.token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorData = (await response.json());
+            return {
+                success: false,
+                added: 0,
+                updated: 0,
+                unchanged: 0,
+                error: errorData.error || `HTTP ${response.status}`,
+            };
+        }
+        const data = (await response.json());
+        const endpoints = data.endpoints || [];
+        logger.flow('Received endpoints from Orquesta', { count: endpoints.length });
+        const result = await configManager.mergeOrquestaEndpoints(endpoints);
+        logger.flow('Sync complete', result);
+        return {
+            success: true,
+            ...result,
+        };
+    }
+    catch (error) {
+        logger.error('Failed to sync configs from Orquesta', error);
+        return {
+            success: false,
+            added: 0,
+            updated: 0,
+            unchanged: 0,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export async function pushConfigsToOrquesta() {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        return {
+            success: false,
+            error: 'Not connected to Orquesta',
+        };
+    }
+    try {
+        const endpoints = configManager.getLocalOnlyEndpoints();
+        if (endpoints.length === 0) {
+            return {
+                success: true,
+                results: [],
+            };
+        }
+        logger.flow('Pushing configs to Orquesta', { count: endpoints.length });
+        const response = await fetch(`${ORQUESTA_API}/api/orquesta-cli/config/sync`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${orquestaConfig.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ endpoints }),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json());
+            return {
+                success: false,
+                error: errorData.error || `HTTP ${response.status}`,
+            };
+        }
+        const data = (await response.json());
+        logger.flow('Push complete', { results: data.results });
+        return {
+            success: true,
+            results: data.results,
+        };
+    }
+    catch (error) {
+        logger.error('Failed to push configs to Orquesta', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export async function submitPromptToOrquesta(prompt) {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        return { success: false, error: 'Not connected to Orquesta' };
+    }
+    try {
+        const response = await fetch(`${ORQUESTA_API}/api/orquesta-cli/prompts`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${orquestaConfig.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                content: prompt.content,
+                context: prompt.context,
+                cliType: 'orquesta-cli',
+                llmConfig: prompt.llmConfig,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json());
+            return {
+                success: false,
+                error: errorData.error || `HTTP ${response.status}`,
+            };
+        }
+        const data = (await response.json());
+        return {
+            success: true,
+            promptId: data.prompt.id,
+        };
+    }
+    catch (error) {
+        logger.warn('Failed to submit prompt to Orquesta', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Network error',
+        };
+    }
+}
+export async function updatePromptStatus(promptId, update) {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        return { success: false, error: 'Not connected to Orquesta' };
+    }
+    try {
+        const response = await fetch(`${ORQUESTA_API}/api/orquesta-cli/prompts`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${orquestaConfig.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                promptId,
+                ...update,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json());
+            return {
+                success: false,
+                error: errorData.error || `HTTP ${response.status}`,
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Network error',
+        };
+    }
+}
+export async function fullSync() {
+    const pullResult = await syncOrquestaConfigs();
+    const pushResult = await pushConfigsToOrquesta();
+    return { pullResult, pushResult };
+}
+//# sourceMappingURL=config-sync.js.map

package/dist/orquesta/prompt-reporter.d.ts

@@ -0,0 +1,16 @@
+export declare function reportPromptStart(content: string, context?: {
+    cwd?: string;
+    model?: string;
+    endpoint?: string;
+}): Promise<string | null>;
+export declare function reportPromptComplete(trackingId: string, result: {
+    success: boolean;
+    output?: string;
+    error?: string;
+    tokensUsed?: number;
+    costCents?: number;
+}): Promise<void>;
+export declare function reportPromptCancelled(trackingId: string): Promise<void>;
+export declare function getActivePromptCount(): number;
+export declare function cleanupOldPrompts(maxAgeMs?: number): void;
+//# sourceMappingURL=prompt-reporter.d.ts.map

package/dist/orquesta/prompt-reporter.js

@@ -0,0 +1,85 @@
+import { configManager } from '../core/config/config-manager.js';
+import { submitPromptToOrquesta, updatePromptStatus } from './config-sync.js';
+import { logger } from '../utils/logger.js';
+const activePrompts = new Map();
+export async function reportPromptStart(content, context) {
+    if (!configManager.hasOrquestaConnection()) {
+        return null;
+    }
+    try {
+        const result = await submitPromptToOrquesta({
+            content,
+            context: {
+                cwd: context?.cwd || process.cwd(),
+                timestamp: Date.now(),
+            },
+            llmConfig: context?.model && context?.endpoint
+                ? { endpoint: context.endpoint, model: context.model }
+                : undefined,
+        });
+        if (result.success && result.promptId) {
+            activePrompts.set(result.promptId, {
+                promptId: result.promptId,
+                startTime: Date.now(),
+                content,
+            });
+            await updatePromptStatus(result.promptId, { status: 'running' });
+            return result.promptId;
+        }
+        return null;
+    }
+    catch (error) {
+        logger.warn('Failed to report prompt start', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+export async function reportPromptComplete(trackingId, result) {
+    if (!trackingId || !configManager.hasOrquestaConnection()) {
+        return;
+    }
+    try {
+        await updatePromptStatus(trackingId, {
+            status: result.success ? 'completed' : 'failed',
+            result: result.output,
+            error: result.error,
+            tokensUsed: result.tokensUsed,
+            costCents: result.costCents,
+        });
+        activePrompts.delete(trackingId);
+    }
+    catch (error) {
+        logger.warn('Failed to report prompt completion', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+export async function reportPromptCancelled(trackingId) {
+    if (!trackingId || !configManager.hasOrquestaConnection()) {
+        return;
+    }
+    try {
+        await updatePromptStatus(trackingId, {
+            status: 'cancelled',
+        });
+        activePrompts.delete(trackingId);
+    }
+    catch (error) {
+        logger.warn('Failed to report prompt cancellation', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+export function getActivePromptCount() {
+    return activePrompts.size;
+}
+export function cleanupOldPrompts(maxAgeMs = 3600000) {
+    const now = Date.now();
+    for (const [id, prompt] of activePrompts) {
+        if (now - prompt.startTime > maxAgeMs) {
+            activePrompts.delete(id);
+        }
+    }
+}
+//# sourceMappingURL=prompt-reporter.js.map

package/dist/setup/first-run-setup.d.ts

@@ -0,0 +1,15 @@
+interface FirstRunResult {
+    connected: boolean;
+    organizationName?: string;
+    projectName?: string;
+    configsSynced?: number;
+    skipped?: boolean;
+}
+export declare function needsFirstRunSetup(): boolean;
+export declare function runFirstRunSetup(token?: string): Promise<FirstRunResult>;
+export declare function connectWithToken(token: string, projectId?: string): Promise<FirstRunResult>;
+export declare function switchProject(projectId?: string): Promise<boolean>;
+export declare function disconnectFromOrquesta(): Promise<void>;
+export declare function showConnectionStatus(): void;
+export {};
+//# sourceMappingURL=first-run-setup.d.ts.map

package/dist/setup/first-run-setup.js

@@ -0,0 +1,238 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { configManager } from '../core/config/config-manager.js';
+import { syncOrquestaConfigs, fetchOrquestaProjects } from '../orquesta/config-sync.js';
+export function needsFirstRunSetup() {
+    return !configManager.hasEndpoints() && !configManager.hasOrquestaConnection();
+}
+export async function runFirstRunSetup(token) {
+    if (token) {
+        return await connectWithToken(token);
+    }
+    return { connected: false, skipped: true };
+}
+export async function connectWithToken(token, projectId) {
+    const spinner = ora({
+        text: chalk.cyan('Validating token...'),
+        color: 'cyan',
+    }).start();
+    try {
+        const projectsData = await fetchOrquestaProjects(token);
+        if (!projectsData) {
+            spinner.fail(chalk.red('Invalid token or failed to fetch projects'));
+            return { connected: false };
+        }
+        const { organization, projects } = projectsData;
+        if (projects.length === 0) {
+            spinner.fail(chalk.red('No projects found in organization'));
+            return { connected: false };
+        }
+        spinner.succeed(chalk.green(`Connected to organization: ${organization.name}`));
+        let selectedProject;
+        if (projectId) {
+            const found = projects.find((p) => p.id === projectId);
+            if (!found) {
+                console.log(chalk.red(`Project ID ${projectId} not found in organization`));
+                return { connected: false };
+            }
+            selectedProject = found;
+        }
+        else if (projects.length === 1) {
+            selectedProject = projects[0];
+            console.log(chalk.cyan(`  Auto-selected project: ${selectedProject.name}`));
+        }
+        else {
+            console.log();
+            console.log(chalk.cyan('  Select a project to work with:'));
+            console.log();
+            projects.forEach((project, index) => {
+                console.log(chalk.white(`    ${index + 1}. ${project.name}`));
+                if (project.description) {
+                    console.log(chalk.dim(`       ${project.description}`));
+                }
+            });
+            console.log();
+            console.log(chalk.dim(`  Enter project number (1-${projects.length}), or press Enter for ${projects[0].name}:`));
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk.cyan('  > '), (ans) => {
+                    rl.close();
+                    resolve(ans.trim());
+                });
+            });
+            if (!answer) {
+                selectedProject = projects[0];
+            }
+            else {
+                const num = parseInt(answer, 10);
+                if (isNaN(num) || num < 1 || num > projects.length) {
+                    console.log(chalk.red(`Invalid selection. Using ${projects[0].name}`));
+                    selectedProject = projects[0];
+                }
+                else {
+                    selectedProject = projects[num - 1];
+                }
+            }
+        }
+        console.log(chalk.green(`  Selected project: ${selectedProject.name}`));
+        await configManager.setOrquestaConfig({
+            token,
+            organizationId: organization.id,
+            organizationName: organization.name,
+            projectId: selectedProject.id,
+            projectName: selectedProject.name,
+            autoSync: true,
+            connectedAt: new Date().toISOString(),
+        });
+        spinner.start(chalk.cyan('Syncing LLM configurations...'));
+        const syncResult = await syncOrquestaConfigs();
+        if (syncResult.success) {
+            const total = syncResult.added + syncResult.updated;
+            if (total > 0) {
+                spinner.succeed(chalk.green(`Synced ${total} LLM configuration(s) (${syncResult.added} new, ${syncResult.updated} updated)`));
+            }
+            else {
+                spinner.info(chalk.yellow('No LLM configurations found in dashboard. Use /config to add endpoints.'));
+            }
+        }
+        else {
+            spinner.warn(chalk.yellow(`Sync warning: ${syncResult.error}`));
+        }
+        console.log();
+        console.log(chalk.cyan('  You are now connected to Orquesta!'));
+        console.log(chalk.dim(`  Organization: ${organization.name}`));
+        console.log(chalk.dim(`  Project: ${selectedProject.name}`));
+        console.log(chalk.dim(`  Your prompts and configs will sync with the dashboard.`));
+        console.log();
+        console.log(chalk.dim(`  Use --switch-project to change projects`));
+        console.log();
+        return {
+            connected: true,
+            organizationName: organization.name,
+            projectName: selectedProject.name,
+            configsSynced: syncResult.added + syncResult.updated,
+        };
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to connect to Orquesta'));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        return { connected: false };
+    }
+}
+export async function switchProject(projectId) {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        console.log(chalk.yellow('Not connected to Orquesta.'));
+        return false;
+    }
+    const spinner = ora({
+        text: chalk.cyan('Fetching projects...'),
+        color: 'cyan',
+    }).start();
+    try {
+        const projectsData = await fetchOrquestaProjects(orquestaConfig.token);
+        if (!projectsData) {
+            spinner.fail(chalk.red('Failed to fetch projects'));
+            return false;
+        }
+        const { organization, projects } = projectsData;
+        spinner.stop();
+        if (projects.length === 0) {
+            console.log(chalk.red('No projects found in organization'));
+            return false;
+        }
+        let selectedProject;
+        if (projectId) {
+            const found = projects.find((p) => p.id === projectId);
+            if (!found) {
+                console.log(chalk.red(`Project ID ${projectId} not found in organization`));
+                return false;
+            }
+            selectedProject = found;
+        }
+        else {
+            console.log();
+            console.log(chalk.cyan(`  Organization: ${organization.name}`));
+            console.log(chalk.cyan(`  Current project: ${orquestaConfig.projectName || 'None'}`));
+            console.log();
+            console.log(chalk.cyan('  Select a project:'));
+            console.log();
+            projects.forEach((project, index) => {
+                const current = project.id === orquestaConfig.projectId ? chalk.green(' (current)') : '';
+                console.log(chalk.white(`    ${index + 1}. ${project.name}${current}`));
+                if (project.description) {
+                    console.log(chalk.dim(`       ${project.description}`));
+                }
+            });
+            console.log();
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk.cyan(`  Enter project number (1-${projects.length}): `), (ans) => {
+                    rl.close();
+                    resolve(ans.trim());
+                });
+            });
+            const num = parseInt(answer, 10);
+            if (isNaN(num) || num < 1 || num > projects.length) {
+                console.log(chalk.red('Invalid selection'));
+                return false;
+            }
+            selectedProject = projects[num - 1];
+        }
+        await configManager.setOrquestaConfig({
+            ...orquestaConfig,
+            projectId: selectedProject.id,
+            projectName: selectedProject.name,
+        });
+        console.log(chalk.green(`  Switched to project: ${selectedProject.name}`));
+        return true;
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to switch project'));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        return false;
+    }
+}
+export async function disconnectFromOrquesta() {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        console.log(chalk.yellow('Not connected to Orquesta.'));
+        return;
+    }
+    const spinner = ora({
+        text: chalk.cyan('Disconnecting from Orquesta...'),
+        color: 'cyan',
+    }).start();
+    try {
+        await configManager.clearOrquestaConnection();
+        spinner.succeed(chalk.green('Disconnected from Orquesta'));
+        console.log(chalk.dim('Local LLM configurations are preserved.'));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to disconnect'));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+export function showConnectionStatus() {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        console.log(chalk.yellow('Not connected to Orquesta'));
+        console.log(chalk.dim('Run: orquesta --token <token> to connect'));
+        return;
+    }
+    console.log(chalk.green('Connected to Orquesta'));
+    console.log(chalk.dim(`  Organization: ${orquestaConfig.organizationName || 'Unknown'}`));
+    console.log(chalk.dim(`  Project: ${orquestaConfig.projectName || 'Unknown'}`));
+    console.log(chalk.dim(`  Connected: ${orquestaConfig.connectedAt ? new Date(orquestaConfig.connectedAt).toLocaleString() : 'Unknown'}`));
+    console.log(chalk.dim(`  Last sync: ${orquestaConfig.lastSyncAt ? new Date(orquestaConfig.lastSyncAt).toLocaleString() : 'Never'}`));
+    console.log(chalk.dim(`  Auto-sync: ${orquestaConfig.autoSync !== false ? 'Enabled' : 'Disabled'}`));
+}
+//# sourceMappingURL=first-run-setup.js.map

package/dist/types/index.d.ts

@@ -92,6 +92,16 @@ export interface SessionMemory {
         includedFiles: string[];
     };
 }
+export interface OrquestaConfig {
+    token?: string;
+    organizationId?: string;
+    organizationName?: string;
+    projectId?: string;
+    projectName?: string;
+    autoSync?: boolean;
+    lastSyncAt?: string;
+    connectedAt?: string;
+}
 export interface OpenConfig {
     version: string;
     currentEndpoint?: string;
@@ -105,8 +115,7 @@ export interface OpenConfig {
     };
     enabledTools?: string[];
     safeEnvVars?: string[];
-    orquestaToken?: string;
-    preferredAgent?: 'local' | 'orquesta' | 'ask';
+    orquesta?: OrquestaConfig;
 }
 export interface TodoItem {
     id: string;

package/dist/ui/TodoPanel.d.ts

@@ -8,6 +8,7 @@ interface TodoPanelProps {
 export declare const TodoPanel: React.FC<TodoPanelProps>;
 export declare const TodoStatusBar: React.FC<{
     todos: TodoItem[];
+    projectName?: string;
 }>;
 export default TodoPanel;
 //# sourceMappingURL=TodoPanel.d.ts.map

package/dist/ui/TodoPanel.js

@@ -100,7 +100,7 @@ export const TodoPanel = React.memo(({ todos, currentTodoId, isProcessing = fals
     }
     return true;
 });
-export const TodoStatusBar = React.memo(({ todos }) => {
+export const TodoStatusBar = React.memo(({ todos, projectName }) => {
     useEffect(() => {
         logger.debug('TodoStatusBar rendered', { todoCount: todos.length });
     }, [todos.length]);
@@ -112,6 +112,11 @@ export const TodoStatusBar = React.memo(({ todos }) => {
     const currentTodo = todos.find(t => t.status === 'in_progress');
     const percentage = Math.round((completedCount / todos.length) * 100);
     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 "))),
         React.createElement(Text, { color: "greenBright" }, '▓'.repeat(Math.round(percentage / 10))),
         React.createElement(Text, { color: "white" }, '░'.repeat(10 - Math.round(percentage / 10))),
         React.createElement(Text, { color: "cyan" },