orquesta-cli 0.1.12 → 0.1.14

package/README.md

@@ -144,14 +144,14 @@ Every file modification requires your explicit approval:
 ### Slash Commands
 | Command | Description |
 |---------|-------------|
-| `/help` | Help |
+| `/help` | Show available commands |
 | `/clear` | Reset conversation |
 | `/compact` | Compress conversation |
 | `/load` | Load saved session |
-| `/model` | Switch model |
+| `/model` | Switch LLM model |
 | `/settings` | Settings menu |
-| `/usage` | Token usage |
-| `/docs` | Docs management |
+| `/usage` | Token usage statistics |
+| `/sync` | Sync LLM configs with Orquesta dashboard |
 | `/tool` | Toggle optional tools (browser/office) |
 
 ### Keyboard Shortcuts
@@ -172,6 +172,11 @@ orquesta [options]
 
 Options:
   -p, --print <prompt>           Execute a prompt and exit (non-interactive)
+  --token <token>                Connect to Orquesta with CLI token (oclt_xxx)
+  --switch-project [projectId]   Switch to different project
+  --status                       Show Orquesta connection status
+  --disconnect                   Disconnect from Orquesta
+  --sync                         Sync LLM configs with dashboard
   --dangerously-skip-permissions Skip all permission prompts (auto-approve)
   --verbose                      Enable verbose logging
   --debug                        Enable debug logging
@@ -180,6 +185,27 @@ Options:
   -V, --version                  Output version number
 ```
 
+### Orquesta Dashboard Integration
+
+Connect to [Orquesta](https://orquesta.live) to sync LLM configurations across your team:
+
+```bash
+# First time: Connect with token (get from https://orquesta.live/dashboard/orquesta-cli)
+orquesta --token oclt_xxxxx
+
+# You'll see a project selector - choose your project
+# LLM endpoints will auto-sync from dashboard
+
+# Later: Switch to different project
+orquesta --switch-project
+
+# Check connection status
+orquesta --status
+
+# Manual sync (also available via /sync command while running)
+orquesta --sync
+```
+
 ---
 
 ## Office Automation (60+ Tools)

package/dist/cli.js

@@ -11,6 +11,8 @@ import { setupLogging, logger } from './utils/logger.js';
 import { runEvalMode } from './eval/index.js';
 import { initializeOptionalTools } from './tools/registry.js';
 import { sessionManager } from './core/session/session-manager.js';
+import { connectWithToken, showConnectionStatus, disconnectFromOrquesta, switchProject } from './setup/first-run-setup.js';
+import { syncOrquestaConfigs } from './orquesta/config-sync.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 const program = new Command();
@@ -26,11 +28,53 @@ program
     .option('--debug', 'Enable debug logging')
     .option('--llm-log', 'Enable LLM logging')
     .option('--eval', 'Evaluation mode: read JSON from stdin, output NDJSON events')
+    .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')
+    .option('--status', 'Show Orquesta connection status and exit')
+    .option('--disconnect', 'Disconnect from Orquesta and exit')
+    .option('--sync', 'Sync configurations with Orquesta and exit')
     .action(async (options) => {
     if (options.eval) {
         await runEvalMode();
         return;
     }
+    await configManager.initialize();
+    if (options.status) {
+        showConnectionStatus();
+        return;
+    }
+    if (options.disconnect) {
+        await disconnectFromOrquesta();
+        return;
+    }
+    if (options.switchProject !== undefined) {
+        const projectId = typeof options.switchProject === 'string' ? options.switchProject : undefined;
+        const success = await switchProject(projectId);
+        process.exit(success ? 0 : 1);
+    }
+    if (options.token) {
+        const result = await connectWithToken(options.token, options.project);
+        if (!result.connected) {
+            process.exit(1);
+        }
+    }
+    if (options.sync) {
+        if (!configManager.hasOrquestaConnection()) {
+            console.log(chalk.yellow('Not connected to Orquesta. Use --token to connect first.'));
+            process.exit(1);
+        }
+        const ora = (await import('ora')).default;
+        const spinner = ora({ text: chalk.cyan('Syncing configurations...'), color: 'cyan' }).start();
+        const result = await syncOrquestaConfigs();
+        if (result.success) {
+            spinner.succeed(chalk.green(`Synced: ${result.added} added, ${result.updated} updated, ${result.unchanged} unchanged`));
+        }
+        else {
+            spinner.fail(chalk.red(`Sync failed: ${result.error}`));
+        }
+        return;
+    }
     if (options.print) {
         const { EvalRunner } = await import('./eval/eval-runner.js');
         const runner = new EvalRunner();
@@ -63,13 +107,24 @@ program
             platform: process.platform,
             nodeVersion: process.version,
         });
-        spinner.text = chalk.cyan('Loading configuration...');
-        logger.flow('Initializing config manager');
-        await configManager.initialize();
-        logger.flow('Config manager initialized');
+        logger.flow('Config manager already initialized');
+        spinner.text = chalk.cyan('Loading tools...');
         logger.flow('Initializing optional tools');
         await initializeOptionalTools();
         logger.flow('Optional tools initialized');
+        if (configManager.hasOrquestaConnection() && configManager.shouldAutoSync()) {
+            spinner.text = chalk.cyan('Syncing with Orquesta...');
+            logger.flow('Auto-syncing with Orquesta');
+            try {
+                const syncResult = await syncOrquestaConfigs();
+                if (syncResult.success && (syncResult.added > 0 || syncResult.updated > 0)) {
+                    logger.flow('Orquesta sync complete', { added: syncResult.added, updated: syncResult.updated });
+                }
+            }
+            catch (error) {
+                logger.warn('Orquesta sync failed', { error: error instanceof Error ? error.message : String(error) });
+            }
+        }
         spinner.text = chalk.cyan('Connecting to LLM...');
         let llmClient = null;
         let modelInfo = { model: 'Not configured', endpoint: 'Not configured' };
@@ -135,6 +190,12 @@ program.on('command:*', () => {
     console.error(chalk.red('⚠️  Unknown command.'));
     console.log(chalk.white('Usage: orquesta [options]\n'));
     console.log(chalk.white('  -p, --print <prompt>    Execute a prompt and exit\n'));
+    console.log(chalk.white('  --token <token>         Connect to Orquesta dashboard\n'));
+    console.log(chalk.white('  --project <id>          Select project when connecting\n'));
+    console.log(chalk.white('  --switch-project [id]   Switch to a different project\n'));
+    console.log(chalk.white('  --status                Show Orquesta connection status\n'));
+    console.log(chalk.white('  --sync                  Sync configurations with Orquesta\n'));
+    console.log(chalk.white('  --disconnect            Disconnect from Orquesta\n'));
     console.log(chalk.white('  --verbose               Enable verbose logging\n'));
     console.log(chalk.white('  --debug                 Enable debug logging\n'));
     console.log(chalk.white('\nUse /help in interactive mode for more help.\n'));

package/dist/constants.js

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as os from 'os';
-export const LOCAL_HOME_DIR = path.join(os.homedir(), '.hanseol');
+export const LOCAL_HOME_DIR = path.join(os.homedir(), '.orquesta-cli');
 export const OPEN_HOME_DIR = LOCAL_HOME_DIR;
 export const CONFIG_FILE_PATH = path.join(LOCAL_HOME_DIR, 'config.json');
 export const DOCS_DIR = path.join(LOCAL_HOME_DIR, 'docs');

package/dist/core/config/config-manager.d.ts

@@ -1,4 +1,4 @@
-import { OpenConfig, EndpointConfig, ModelInfo } from '../../types/index.js';
+import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig } from '../../types/index.js';
 export declare class ConfigManager {
     private config;
     private initialized;
@@ -39,6 +39,18 @@ export declare class ConfigManager {
     setEnabledTools(toolIds: string[]): Promise<void>;
     enableTool(toolId: string): Promise<void>;
     disableTool(toolId: string): Promise<void>;
+    hasOrquestaConnection(): boolean;
+    shouldAutoSync(): boolean;
+    getOrquestaConfig(): OrquestaConfig | undefined;
+    setOrquestaConfig(orquestaConfig: OrquestaConfig): Promise<void>;
+    clearOrquestaConnection(): Promise<void>;
+    updateLastSync(): Promise<void>;
+    mergeOrquestaEndpoints(orquestaEndpoints: EndpointConfig[]): Promise<{
+        added: number;
+        updated: number;
+        unchanged: number;
+    }>;
+    getLocalOnlyEndpoints(): EndpointConfig[];
 }
 export declare const configManager: ConfigManager;
 //# sourceMappingURL=config-manager.d.ts.map

package/dist/core/config/config-manager.js

@@ -254,6 +254,89 @@ export class ConfigManager {
             await this.saveConfig();
         }
     }
+    hasOrquestaConnection() {
+        if (!this.config) {
+            return false;
+        }
+        return !!this.config.orquesta?.token;
+    }
+    shouldAutoSync() {
+        if (!this.config?.orquesta) {
+            return false;
+        }
+        return this.config.orquesta.autoSync !== false;
+    }
+    getOrquestaConfig() {
+        return this.config?.orquesta;
+    }
+    async setOrquestaConfig(orquestaConfig) {
+        const config = this.getConfig();
+        config.orquesta = {
+            ...config.orquesta,
+            ...orquestaConfig,
+        };
+        await this.saveConfig();
+    }
+    async clearOrquestaConnection() {
+        const config = this.getConfig();
+        config.orquesta = undefined;
+        await this.saveConfig();
+    }
+    async updateLastSync() {
+        if (!this.config?.orquesta) {
+            return;
+        }
+        this.config.orquesta.lastSyncAt = new Date().toISOString();
+        await this.saveConfig();
+    }
+    async mergeOrquestaEndpoints(orquestaEndpoints) {
+        const config = this.getConfig();
+        let added = 0;
+        let updated = 0;
+        let unchanged = 0;
+        for (const remoteEndpoint of orquestaEndpoints) {
+            const existingIndex = config.endpoints.findIndex((ep) => ep.id === remoteEndpoint.id || ep.name === remoteEndpoint.name);
+            if (existingIndex >= 0) {
+                const existing = config.endpoints[existingIndex];
+                const hasChanges = existing.baseUrl !== remoteEndpoint.baseUrl ||
+                    existing.apiKey !== remoteEndpoint.apiKey ||
+                    JSON.stringify(existing.models) !== JSON.stringify(remoteEndpoint.models);
+                if (hasChanges) {
+                    config.endpoints[existingIndex] = {
+                        ...remoteEndpoint,
+                        id: existing.id,
+                        updatedAt: new Date(),
+                    };
+                    updated++;
+                }
+                else {
+                    unchanged++;
+                }
+            }
+            else {
+                config.endpoints.push({
+                    ...remoteEndpoint,
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                });
+                added++;
+            }
+        }
+        if (!config.currentEndpoint && config.endpoints.length > 0) {
+            config.currentEndpoint = config.endpoints[0].id;
+            const firstModel = config.endpoints[0].models.find((m) => m.enabled);
+            if (firstModel) {
+                config.currentModel = firstModel.id;
+            }
+        }
+        await this.saveConfig();
+        await this.updateLastSync();
+        return { added, updated, unchanged };
+    }
+    getLocalOnlyEndpoints() {
+        const config = this.getConfig();
+        return config.endpoints;
+    }
 }
 export const configManager = new ConfigManager();
 //# sourceMappingURL=config-manager.js.map

package/dist/core/slash-command-handler.d.ts

@@ -18,6 +18,7 @@ export interface CommandHandlerContext {
     onShowSessionBrowser?: () => void;
     onShowSettings?: () => void;
     onShowModelSelector?: () => void;
+    onShowProjectSelector?: () => void;
     onShowToolSelector?: () => void;
     onCompact?: () => Promise<CompactResult>;
 }

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

@@ -1,6 +1,8 @@
 import { sessionManager } from './session/session-manager.js';
 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';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
@@ -144,6 +146,124 @@ export async function executeSlashCommand(command, context) {
             },
         };
     }
+    if (trimmedCommand === '/sync') {
+        logger.flow('Sync command received');
+        const orquestaConfig = configManager.getOrquestaConfig();
+        if (!orquestaConfig?.token) {
+            const notConnectedMessage = `❌ Not connected to Orquesta.\n\nTo sync configurations, first connect using an Orquesta CLI token:\n1. Go to https://orquesta.live/dashboard/orquesta-cli\n2. Generate a CLI token\n3. Run orquesta-cli again and enter your token`;
+            const updatedMessages = [
+                ...context.messages,
+                { role: 'assistant', content: notConnectedMessage },
+            ];
+            context.setMessages(updatedMessages);
+            return {
+                handled: true,
+                shouldContinue: false,
+                updatedContext: {
+                    messages: updatedMessages,
+                },
+            };
+        }
+        const syncingMessage = `🔄 Syncing with Orquesta (${orquestaConfig.projectName || 'project'})...`;
+        const inProgressMessages = [
+            ...context.messages,
+            { role: 'assistant', content: syncingMessage },
+        ];
+        context.setMessages(inProgressMessages);
+        try {
+            const { pullResult, pushResult } = await fullSync();
+            let resultMessage = '';
+            if (pullResult.success) {
+                if (pullResult.added > 0 || pullResult.updated > 0) {
+                    resultMessage += `✅ Pulled from dashboard: ${pullResult.added} added, ${pullResult.updated} updated\n`;
+                }
+                else {
+                    resultMessage += `✅ Pulled from dashboard: No changes\n`;
+                }
+            }
+            else {
+                resultMessage += `⚠️ Pull failed: ${pullResult.error}\n`;
+            }
+            if (pushResult.success) {
+                const pushed = pushResult.results?.length || 0;
+                if (pushed > 0) {
+                    resultMessage += `✅ Pushed to dashboard: ${pushed} endpoint(s)`;
+                }
+                else {
+                    resultMessage += `✅ Pushed to dashboard: No local changes`;
+                }
+            }
+            else {
+                resultMessage += `⚠️ Push failed: ${pushResult.error}`;
+            }
+            const updatedMessages = [
+                ...context.messages,
+                { role: 'assistant', content: resultMessage },
+            ];
+            context.setMessages(updatedMessages);
+            return {
+                handled: true,
+                shouldContinue: false,
+                updatedContext: {
+                    messages: updatedMessages,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = `❌ Sync failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            const updatedMessages = [
+                ...context.messages,
+                { role: 'assistant', content: errorMessage },
+            ];
+            context.setMessages(updatedMessages);
+            return {
+                handled: true,
+                shouldContinue: false,
+                updatedContext: {
+                    messages: updatedMessages,
+                },
+            };
+        }
+    }
+    if (trimmedCommand === '/project') {
+        logger.flow('Project command received');
+        const orquestaConfig = configManager.getOrquestaConfig();
+        if (!orquestaConfig?.token) {
+            const notConnectedMessage = `❌ Not connected to Orquesta.\n\nTo switch projects, first connect using an Orquesta CLI token:\n1. Go to https://orquesta.live/dashboard/orquesta-cli\n2. Generate a CLI token\n3. Restart with: orquesta --token <your-token>`;
+            const updatedMessages = [
+                ...context.messages,
+                { role: 'assistant', content: notConnectedMessage },
+            ];
+            context.setMessages(updatedMessages);
+            return {
+                handled: true,
+                shouldContinue: false,
+                updatedContext: {
+                    messages: updatedMessages,
+                },
+            };
+        }
+        if (context.onShowProjectSelector) {
+            context.onShowProjectSelector();
+            return {
+                handled: true,
+                shouldContinue: false,
+            };
+        }
+        const projectMessage = `Use /project in interactive mode to switch between projects.\n\nCurrent project: ${orquestaConfig.projectName || 'Unknown'}`;
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: projectMessage },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: {
+                messages: updatedMessages,
+            },
+        };
+    }
     if (trimmedCommand === '/help') {
         const helpMessage = `
 Available commands:
@@ -152,14 +272,23 @@ Available commands:
   /compact        - Compact conversation to free up context
   /settings       - Open settings menu
   /model          - Switch between LLM models
+  /project        - Switch between Orquesta projects
   /tool           - Enable/disable optional tools (Browser, Background)
   /load           - Load a saved session
   /usage          - Show token usage statistics
+  /sync           - Bidirectional sync with Orquesta dashboard (pull & push LLM configs)
+
+CLI Options (restart required):
+  --token <token>          - Connect to Orquesta with CLI token
+  --status                 - Show Orquesta connection status
+  --disconnect             - Disconnect from Orquesta
 
 Keyboard shortcuts:
   Ctrl+C          - Exit
   Ctrl+T          - Toggle TODO details
   ESC             - Interrupt current execution
+  @               - File browser
+  /               - Command autocomplete
 
 Note: All conversations are automatically saved.
     `;

package/dist/orquesta/config-sync.d.ts

@@ -0,0 +1,73 @@
+interface ValidationResponse {
+    valid: boolean;
+    projectId?: string;
+    projectName?: string;
+    organizationId?: string;
+    organizationName?: string;
+    tokenName?: string;
+    supabaseUrl?: string;
+    supabaseAnonKey?: string;
+    channelName?: string;
+    error?: string;
+}
+interface OrquestaProject {
+    id: string;
+    name: string;
+    slug?: string;
+    description?: string;
+}
+interface ProjectsResponse {
+    organization: {
+        id: string;
+        name: string;
+    };
+    projects: OrquestaProject[];
+}
+interface SyncResult {
+    success: boolean;
+    added: number;
+    updated: number;
+    unchanged: number;
+    error?: string;
+}
+interface PushResult {
+    success: boolean;
+    results?: Array<{
+        id: string;
+        status?: string;
+        error?: string;
+    }>;
+    error?: string;
+}
+export declare function fetchOrquestaProjects(token: string): Promise<ProjectsResponse | null>;
+export declare function validateOrquestaToken(token: string): Promise<ValidationResponse>;
+export declare function syncOrquestaConfigs(): Promise<SyncResult>;
+export declare function pushConfigsToOrquesta(): Promise<PushResult>;
+export declare function submitPromptToOrquesta(prompt: {
+    content: string;
+    context?: Record<string, unknown>;
+    llmConfig?: {
+        endpoint: string;
+        model: string;
+    };
+}): Promise<{
+    success: boolean;
+    promptId?: string;
+    error?: string;
+}>;
+export declare function updatePromptStatus(promptId: string, update: {
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    result?: string;
+    error?: string;
+    tokensUsed?: number;
+    costCents?: number;
+}): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare function fullSync(): Promise<{
+    pullResult: SyncResult;
+    pushResult: PushResult;
+}>;
+export {};
+//# sourceMappingURL=config-sync.d.ts.map