vutler-nexus 1.0.0 → 2.0.0

package/bin/cli.js

@@ -14,6 +14,7 @@ const { NexusTunnel } = require('../lib/tunnel');
 const { AgentRuntime } = require('../lib/agent-runtime');
 const { WebServer } = require('../lib/web-server');
 const { listProviders } = require('../lib/llm-providers');
+const NexusCloudOrchestrator = require('../lib/orchestrator-cloud');
 const https = require('https');
 const http = require('http');
 const fs = require('fs');
@@ -246,7 +247,43 @@ program
     const workspace = await ask('Workspace path', path.join(process.env.HOME || process.cwd(), '.vutler', 'workspace'));
     const webPort = parseInt(await ask('Web interface port', '3939')) || 3939;
     
-    // LLM Provider Selection
+    // Runtime Mode Selection (Local vs Cloud)
+    console.log(chalk.blue('\n🌐 Execution Mode:'));
+    const modes = [
+      { key: 'local', name: 'Local (Claude CLI)', desc: 'Run agents locally using Claude CLI' },
+      { key: 'cloud', name: 'Cloud (Vutler API)', desc: 'Route tasks to Vutler cloud agents' }
+    ];
+    modes.forEach((m, i) => {
+      console.log(`  ${i + 1}. ${chalk.cyan(m.name)} - ${m.desc}`);
+    });
+    const modeIndex = parseInt(await ask('Select execution mode (number)', '1')) || 1;
+    const selectedMode = modes[modeIndex - 1];
+    
+    if (!selectedMode) {
+      error('Invalid mode selection');
+      process.exit(1);
+    }
+    
+    let cloudConfig = null;
+    if (selectedMode.key === 'cloud') {
+      console.log(chalk.green(`\n📡 Cloud Mode Configuration:`));
+      const vutlerUrl = await ask('Vutler API URL', 'https://app.vutler.ai');
+      const apiKey = await askPassword('VUTLER_API_KEY');
+      
+      if (!apiKey) {
+        warn('⚠️  No API key provided. Cloud mode requires VUTLER_API_KEY');
+        process.exit(1);
+      }
+      
+      cloudConfig = {
+        mode: 'cloud',
+        vutlerUrl,
+        vutlerApiKey: apiKey
+      };
+      console.log(chalk.green('✅ Cloud mode configured'));
+    }
+
+    // LLM Provider Selection (only for local mode)
     console.log(chalk.blue('\n🧠 LLM Provider Selection:'));
     
     // Check available providers
@@ -354,11 +391,14 @@ program
     
     // Build configuration
     const newConfig = {
+      mode: cloudConfig?.mode || 'local',
+      vutlerUrl: cloudConfig?.vutlerUrl,
+      vutlerApiKey: cloudConfig?.vutlerApiKey,
       cloudUrl,
       token: token || null,
       workspace,
       webPort,
-      llm: llmConfig,
+      llm: cloudConfig ? { provider: 'cloud' } : llmConfig,
       auth: authResult || undefined,
       agent: {
         name: agentName,
@@ -396,7 +436,12 @@ program
     
     console.log(chalk.green(`\n✅ Configuration saved to ${config.CONFIG_FILE}`));
     console.log(`   Agent: ${chalk.cyan(agentName)}`);
-    console.log(`   LLM: ${chalk.cyan(providerData.name)}`);
+    console.log(`   Mode: ${chalk.cyan(selectedMode.name)}`);
+    if (cloudConfig) {
+      console.log(`   Vutler API: ${chalk.cyan(cloudConfig.vutlerUrl)}`);
+    } else {
+      console.log(`   LLM: ${chalk.cyan(providerData.name)}`);
+    }
     console.log(`   Workspace: ${chalk.cyan(workspace)}`);
     console.log(`   Web UI: ${chalk.cyan(`http://localhost:${webPort}`)}`);
     if (token) {
@@ -424,8 +469,18 @@ program
     log('🚀 Starting Vutler Nexus Agent Runtime...\n');
     
     try {
+      // Check mode
+      if (cfg.mode === 'cloud') {
+        // Set environment variable for cloud orchestrator
+        if (cfg.vutlerApiKey) {
+          process.env.VUTLER_API_KEY = cfg.vutlerApiKey;
+        }
+        log(`☁️  Cloud Mode - Vutler API: ${cfg.vutlerUrl || 'https://app.vutler.ai'}`);
+      }
+      
       // Initialize agent runtime
-      log(`🧠 Initializing Agent Runtime (${cfg.llm?.provider || 'unknown'})...`);
+      const providerName = cfg.mode === 'cloud' ? 'Cloud (Vutler API)' : (cfg.llm?.provider || 'unknown');
+      log(`🧠 Initializing Agent Runtime (${providerName})...`);
       agentRuntime = new AgentRuntime(cfg);
       success('✅ Agent Runtime ready');
       
@@ -492,8 +547,10 @@ program
         console.log(chalk.blue(`   Cloud: ${cfg.cloudUrl}`));
       }
       
-      const providerName = providerInfo[cfg.llm?.provider]?.name || cfg.llm?.provider || 'Unknown';
-      console.log(chalk.blue(`   LLM: ${providerName}`));
+      if (cfg.mode !== 'cloud') {
+        const llmProviderName = providerInfo[cfg.llm?.provider]?.name || cfg.llm?.provider || 'Unknown';
+        console.log(chalk.blue(`   LLM: ${llmProviderName}`));
+      }
       console.log(chalk.gray('\n   Press Ctrl+C to stop'));
       
     } catch (error) {
@@ -561,36 +618,50 @@ program
     console.log(`  Web Port:     ${cfg.webPort || 'not set'}`);
     
     // LLM status
+    // Determine execution mode
+    const mode = cfg.mode || 'local';
+    console.log(chalk.blue('\n🌐 Execution Mode:'));
+    console.log(`  Mode:         ${mode === 'cloud' ? 'Cloud (Vutler API)' : 'Local'}`);
+    
+    if (mode === 'cloud') {
+      console.log(`  Vutler API:   ${cfg.vutlerUrl || 'https://app.vutler.ai'}`);
+      console.log(`  API Key:      ${cfg.vutlerApiKey ? cfg.vutlerApiKey.slice(0, 8) + '...' : 'not set'}`);
+    }
+    
     console.log(chalk.blue('\n🧠 LLM Configuration:'));
-    const provider = cfg.llm?.provider || 'not set';
-    const providerName = providerInfo[provider]?.name || provider;
+    const provider = mode === 'cloud' ? 'cloud' : (cfg.llm?.provider || 'not set');
+    const providerName = mode === 'cloud' ? 'Cloud Agents' : (providerInfo[provider]?.name || provider);
     console.log(`  Provider:     ${providerName}`);
     
-    if (provider === 'claude-code') {
-      const claudeStatus = await checkClaudeCLI();
-      if (claudeStatus.available) {
-        console.log(`  Claude CLI:   ✅ ${claudeStatus.version}`);
-      } else {
-        console.log(`  Claude CLI:   ❌ not found (install with: pip install claude-cli)`);
-      }
-      console.log(`  Cost:         $0 (uses Max subscription)`);
-    } else if (provider === 'ollama') {
-      const ollamaStatus = await checkOllama();
-      if (ollamaStatus.available) {
-        console.log(`  Ollama:       ✅ running (${ollamaStatus.models.length} models)`);
-      } else {
-        console.log(`  Ollama:       ❌ not running (start with: ollama serve)`);
+    if (mode !== 'cloud') {
+      if (provider === 'claude-code') {
+        const claudeStatus = await checkClaudeCLI();
+        if (claudeStatus.available) {
+          console.log(`  Claude CLI:   ✅ ${claudeStatus.version}`);
+        } else {
+          console.log(`  Claude CLI:   ❌ not found (install with: pip install claude-cli)`);
+        }
+        console.log(`  Cost:         $0 (uses Max subscription)`);
+      } else if (provider === 'ollama') {
+        const ollamaStatus = await checkOllama();
+        if (ollamaStatus.available) {
+          console.log(`  Ollama:       ✅ running (${ollamaStatus.models.length} models)`);
+        } else {
+          console.log(`  Ollama:       ❌ not running (start with: ollama serve)`);
+        }
+        console.log(`  Cost:         $0 (local models)`);
+      } else if (providerInfo[provider]?.requiresApiKey) {
+        console.log(`  API Key:      ${cfg.llm?.apiKey ? cfg.llm.apiKey.slice(0, 8) + '...' : 'not set'}`);
+        console.log(`  Cost:         per token usage`);
       }
-      console.log(`  Cost:         $0 (local models)`);
-    } else if (providerInfo[provider]?.requiresApiKey) {
-      console.log(`  API Key:      ${cfg.llm?.apiKey ? cfg.llm.apiKey.slice(0, 8) + '...' : 'not set'}`);
-      console.log(`  Cost:         per token usage`);
+      
+      console.log(`  Model:        ${cfg.llm?.model || 'not set'}`);
+      console.log(`  Max Tokens:   ${cfg.llm?.maxTokens || 'not set'}`);
+      console.log(`  Temperature:  ${cfg.llm?.temperature || 'not set'}`);
+    } else {
+      console.log(`  Cost:         per cloud agent usage`);
     }
     
-    console.log(`  Model:        ${cfg.llm?.model || 'not set'}`);
-    console.log(`  Max Tokens:   ${cfg.llm?.maxTokens || 'not set'}`);
-    console.log(`  Temperature:  ${cfg.llm?.temperature || 'not set'}`);
-    
     // Cloud status
     console.log(chalk.blue('\n☁️  Cloud Integration:'));
     console.log(`  Cloud URL:    ${cfg.cloudUrl || 'not set'}`);

package/lib/config.js

@@ -139,6 +139,13 @@ function canRunOffline() {
 
 function canUseLLM() {
   const config = read();
+  
+  // Cloud mode
+  if (config.mode === 'cloud') {
+    return !!(config.vutlerApiKey);
+  }
+  
+  // Local mode
   if (config.llm?.provider === 'claude-code') {
     return true; // Assume claude CLI is available
   }

package/lib/orchestrator-cloud.js

@@ -0,0 +1,236 @@
+const VutlerClient = require('./vutler-client');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Nexus Cloud Orchestrator
+ * 
+ * Routes tasks to Vutler cloud agents instead of local execution
+ */
+class NexusCloudOrchestrator {
+  constructor(configPath = null) {
+    // Initialize with default config if no path provided
+    if (configPath) {
+      this.configPath = configPath.replace('~', os.homedir());
+      this.config = this.loadConfig();
+    } else {
+      // Use default minimal config when running from CLI
+      this.config = this.getDefaultConfig();
+    }
+    
+    this.client = new VutlerClient({
+      baseUrl: this.config.vutlerUrl,
+      apiKey: process.env.VUTLER_API_KEY
+    });
+    this.stats = {
+      tasksCompleted: 0,
+      totalCost: 0,
+      agentUsage: {}
+    };
+  }
+
+  /**
+   * Get default cloud configuration
+   */
+  getDefaultConfig() {
+    return {
+      vutlerUrl: process.env.VUTLER_URL || 'https://app.vutler.ai',
+      agents: [
+        { id: 'default', name: 'Default Cloud Agent', enabled: true, location: 'Vutler Cloud' }
+      ],
+      routing: {
+        default: 'default'
+      },
+      limits: {
+        timeoutSeconds: 300
+      }
+    };
+  }
+
+  /**
+   * Load agent configuration from file
+   */
+  loadConfig() {
+    if (!this.configPath || !fs.existsSync(this.configPath)) {
+      // Fall back to default if file doesn't exist
+      return this.getDefaultConfig();
+    }
+    
+    try {
+      const raw = fs.readFileSync(this.configPath, 'utf8');
+      const config = JSON.parse(raw);
+      
+      // Validate
+      if (!config.agents || config.agents.length === 0) {
+        console.warn('No agents defined in config, using default');
+        return this.getDefaultConfig();
+      }
+      
+      if (!config.routing || !config.routing.default) {
+        console.warn('Routing config missing, using default');
+        return this.getDefaultConfig();
+      }
+      
+      return config;
+    } catch (error) {
+      console.warn(`Failed to load config: ${error.message}, using default`);
+      return this.getDefaultConfig();
+    }
+  }
+
+  /**
+   * Route a task to the best cloud agent
+   */
+  routeTask(task, options = {}) {
+    // Force specific agent if requested
+    if (options.forceAgent) {
+      const agent = this.config.agents.find(a => a.id === options.forceAgent);
+      if (agent && agent.enabled) {
+        return options.forceAgent;
+      }
+      console.warn(`Forced agent ${options.forceAgent} not available, falling back`);
+    }
+    
+    // Check keywords
+    const taskLower = task.toLowerCase();
+    
+    for (const [keyword, agentIds] of Object.entries(this.config.routing.keywords || {})) {
+      if (taskLower.includes(keyword)) {
+        // Pick first enabled agent for this keyword
+        for (const agentId of agentIds) {
+          const agent = this.config.agents.find(a => a.id === agentId);
+          if (agent && agent.enabled) {
+            console.log(`🎯 Routing to ${agent.name} (keyword: "${keyword}")`);
+            return agentId;
+          }
+        }
+      }
+    }
+    
+    // Default agent
+    console.log(`📍 Routing to default agent: ${this.config.routing.default}`);
+    return this.config.routing.default;
+  }
+
+  /**
+   * Execute a task via cloud agent
+   */
+  async executeTask(task, options = {}) {
+    const agentId = options.agentId || this.routeTask(task, options);
+    const agent = this.config.agents.find(a => a.id === agentId);
+    
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    
+    if (!agent.enabled) {
+      console.warn(`Agent ${agentId} disabled, falling back to default`);
+      return this.executeTask(task, { ...options, agentId: this.config.routing.default, noFallback: true });
+    }
+
+    console.log(`\n☁️  ${agent.name} (cloud)`);
+    console.log(`   Location: ${agent.location || 'Vutler Cloud'}`);
+    
+    try {
+      const result = await this.client.executeTask(agentId, task, {
+        context: options.context,
+        timeout: options.timeout || this.config.limits?.timeoutSeconds * 1000,
+        userId: options.userId
+      });
+      
+      // Track stats
+      this.stats.tasksCompleted++;
+      this.stats.totalCost += result.cost;
+      this.stats.agentUsage[agentId] = (this.stats.agentUsage[agentId] || 0) + 1;
+      
+      // Log to tracking file if enabled
+      if (this.config.tracking?.enabled) {
+        this.logTask(task, result);
+      }
+      
+      return result;
+      
+    } catch (error) {
+      console.error(`\n❌ Cloud execution failed: ${error.message}`);
+      
+      // Fallback to default agent if not already using it
+      if (agentId !== this.config.routing.default && !options.noFallback) {
+        console.log(`\n🔄 Falling back to ${this.config.routing.default}...`);
+        return this.executeTask(task, { ...options, agentId: this.config.routing.default, noFallback: true });
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Log task execution to JSONL file
+   */
+  logTask(task, result) {
+    const logPath = this.config.tracking.logPath.replace('~', os.homedir());
+    const logDir = path.dirname(logPath);
+    
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    
+    const entry = JSON.stringify({
+      timestamp: result.timestamp,
+      task: task.substring(0, 200),
+      agentId: result.agentId,
+      agentName: result.agentName,
+      source: result.source,
+      duration: result.duration,
+      cost: result.cost,
+      usage: result.usage
+    });
+    
+    fs.appendFileSync(logPath, entry + '\n');
+  }
+
+  /**
+   * Get orchestrator stats
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      averageCost: this.stats.tasksCompleted > 0 
+        ? this.stats.totalCost / this.stats.tasksCompleted 
+        : 0
+    };
+  }
+
+  /**
+   * Test cloud connectivity
+   */
+  async testConnection() {
+    try {
+      const ok = await this.client.ping();
+      if (ok) {
+        console.log('✅ Connected to Vutler Cloud');
+        return true;
+      } else {
+        console.log('❌ Vutler Cloud unreachable');
+        return false;
+      }
+    } catch (error) {
+      console.log(`❌ Connection failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * List available cloud agents
+   */
+  async listCloudAgents() {
+    try {
+      return await this.client.listAgents();
+    } catch (error) {
+      console.error(`Failed to list cloud agents: ${error.message}`);
+      return [];
+    }
+  }
+}
+
+module.exports = NexusCloudOrchestrator;

package/lib/vutler-client.js

@@ -0,0 +1,137 @@
+/**
+ * Vutler Cloud Client
+ * 
+ * Executes tasks via Vutler cloud agents instead of local processes
+ */
+
+class VutlerClient {
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || process.env.VUTLER_API_URL || 'https://app.vutler.ai';
+    this.apiKey = config.apiKey || process.env.VUTLER_API_KEY;
+    
+    if (!this.apiKey) {
+      throw new Error('VUTLER_API_KEY required for cloud agent execution');
+    }
+  }
+
+  /**
+   * Execute a task with a cloud agent
+   */
+  async executeTask(agentId, task, options = {}) {
+    const startTime = Date.now();
+    
+    console.log(`☁️  Executing task via cloud agent: ${agentId}`);
+    
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/agents/${agentId}/execute`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+          'X-User-Id': options.userId || 'default'
+        },
+        body: JSON.stringify({
+          task,
+          context: options.context || {},
+          timeout: options.timeout || 300000,
+          streaming: false
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Cloud agent error (${response.status}): ${error}`);
+      }
+
+      const result = await response.json();
+      const duration = Date.now() - startTime;
+
+      const usage = result.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      if (!usage.totalTokens) {
+        usage.totalTokens = usage.inputTokens + usage.outputTokens;
+      }
+
+      return {
+        agentId,
+        agentName: result.agent?.name || agentId,
+        result: result.output || result.result,
+        duration,
+        cost: result.cost || 0,
+        usage,
+        timestamp: new Date().toISOString(),
+        source: 'cloud'
+      };
+      
+    } catch (error) {
+      console.error(`❌ Cloud execution failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List available cloud agents
+   */
+  async listAgents() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/agents`, {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`
+        }
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to list agents: ${response.status}`);
+      }
+
+      const data = await response.json();
+      return data.agents || [];
+      
+    } catch (error) {
+      console.error(`Failed to list cloud agents: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Get agent details
+   */
+  async getAgent(agentId) {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/agents/${agentId}`, {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`
+        }
+      });
+
+      if (!response.ok) {
+        return null;
+      }
+
+      const data = await response.json();
+      return data.agent;
+      
+    } catch (error) {
+      console.error(`Failed to get agent ${agentId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async ping() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/health`, {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`
+        }
+      });
+
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = VutlerClient;

package/lib/web-server.js

@@ -1,6 +1,7 @@
 /**
  * @vutler/nexus — Local Web Server
  * Express server providing web interface for chat and configuration
+ * Supports both local (Claude CLI) and cloud (Vutler API) modes
  */
 const express = require('express');
 const path = require('path');
@@ -8,16 +9,28 @@ const { EventEmitter } = require('events');
 
 const multer = require('multer');
 const fs = require('fs');
+const NexusCloudOrchestrator = require('./orchestrator-cloud');
 
 class WebServer extends EventEmitter {
   constructor(config, agentRuntime) {
     super();
     this.config = config;
     this.agentRuntime = agentRuntime;
+    this.cloudOrchestrator = null;
     this.app = express();
     this.server = null;
     this.activeConnections = new Set();
     
+    // Initialize cloud orchestrator if in cloud mode
+    if (config.mode === 'cloud' && config.vutlerApiKey) {
+      try {
+        process.env.VUTLER_API_KEY = config.vutlerApiKey;
+        this.cloudOrchestrator = new NexusCloudOrchestrator();
+      } catch (error) {
+        console.error('[web] Failed to initialize cloud orchestrator:', error.message);
+      }
+    }
+    
     this.setupMiddleware();
     this.setupRoutes();
   }
@@ -51,6 +64,8 @@ class WebServer extends EventEmitter {
     this.app.get('/api/status', (req, res) => {
       try {
         const runtimeStatus = this.agentRuntime ? this.agentRuntime.getStatus() : null;
+        const isCloud = this.config.mode === 'cloud' && this.cloudOrchestrator;
+        
         res.json({
           server: 'running',
           agent: runtimeStatus,
@@ -58,11 +73,14 @@ class WebServer extends EventEmitter {
             workspace: this.config.workspace,
             webPort: this.config.webPort,
             agentName: this.config.agent?.name,
-            provider: this.config.llm?.provider,
-            model: this.config.llm?.model,
-            hasApiKey: !!(this.config.llm?.apiKey)
+            mode: this.config.mode || 'local',
+            provider: isCloud ? 'cloud' : this.config.llm?.provider,
+            model: isCloud ? 'Vutler Cloud' : this.config.llm?.model,
+            hasApiKey: !!(this.config.llm?.apiKey || this.config.vutlerApiKey),
+            vutlerUrl: isCloud ? this.config.vutlerUrl : undefined
           },
-          connections: this.activeConnections.size
+          connections: this.activeConnections.size,
+          cloudReady: isCloud
         });
       } catch (error) {
         res.status(500).json({ error: error.message });
@@ -125,7 +143,7 @@ class WebServer extends EventEmitter {
       }
     });
 
-    // Chat endpoint
+    // Chat endpoint - supports both local and cloud modes
     this.app.post('/api/chat', async (req, res) => {
       try {
         const { message, stream = true, attachments = [] } = req.body;
@@ -134,55 +152,109 @@ class WebServer extends EventEmitter {
           return res.status(400).json({ error: 'Message is required' });
         }
 
-        if (!this.agentRuntime) {
-          return res.status(500).json({ error: 'Agent runtime not initialized' });
-        }
-
-        if (!stream) {
-          // Non-streaming response
-          const response = await this.agentRuntime.processMessage(message, { attachments });
-          res.json(response);
-        } else {
-          // Streaming response using Server-Sent Events
-          res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*',
-          });
-
-          // Track connection
-          this.activeConnections.add(res);
-          
-          // Handle client disconnect
-          res.on('close', () => {
-            this.activeConnections.delete(res);
-          });
-
+        // Route based on mode
+        if (this.config.mode === 'cloud' && this.cloudOrchestrator) {
+          // Cloud mode - route to Vutler cloud agents
           try {
-            await this.agentRuntime.processMessage(message, {
-              stream: true,
-              attachments,
-              onChunk: (chunk) => {
+            console.log('[web] ☁️  Cloud mode - executing via Vutler');
+            const result = await this.cloudOrchestrator.executeTask(message, {
+              userId: 'web-ui',
+              stream: false
+            });
+
+            if (!stream) {
+              res.json({
+                type: 'text',
+                content: result.result || result.output || 'No response',
+                source: 'cloud',
+                duration: result.duration,
+                agent: result.agentName
+              });
+            } else {
+              // Streaming cloud response
+              res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*',
+              });
+
+              this.activeConnections.add(res);
+              res.on('close', () => {
+                this.activeConnections.delete(res);
+              });
+
+              // Send result chunks
+              const chunks = (result.result || '').split(' ');
+              for (const chunk of chunks) {
                 if (!res.destroyed) {
-                  res.write(`data: ${JSON.stringify(chunk)}\\n\\n`);
+                  res.write(`data: ${JSON.stringify({ type: 'text', content: chunk + ' ' })}\\n\\n`);
                 }
               }
-            });
-            
-            // Send completion marker
-            if (!res.destroyed) {
-              res.write('data: {"type":"complete"}\\n\\n');
-              res.end();
+
+              if (!res.destroyed) {
+                res.write(`data: ${JSON.stringify({ type: 'complete', agent: result.agentName, duration: result.duration })}\\n\\n`);
+                res.end();
+              }
+
+              this.activeConnections.delete(res);
             }
           } catch (error) {
-            if (!res.destroyed) {
-              res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\\n\\n`);
-              res.end();
+            console.error('[web] Cloud execution error:', error);
+            if (!res.headersSent) {
+              res.status(500).json({ error: error.message });
+            }
+          }
+        } else if (this.agentRuntime) {
+          // Local mode - use agent runtime
+          if (!stream) {
+            // Non-streaming response
+            const response = await this.agentRuntime.processMessage(message, { attachments });
+            res.json(response);
+          } else {
+            // Streaming response using Server-Sent Events
+            res.writeHead(200, {
+              'Content-Type': 'text/event-stream',
+              'Cache-Control': 'no-cache',
+              'Connection': 'keep-alive',
+              'Access-Control-Allow-Origin': '*',
+            });
+
+            // Track connection
+            this.activeConnections.add(res);
+            
+            // Handle client disconnect
+            res.on('close', () => {
+              this.activeConnections.delete(res);
+            });
+
+            try {
+              await this.agentRuntime.processMessage(message, {
+                stream: true,
+                attachments,
+                onChunk: (chunk) => {
+                  if (!res.destroyed) {
+                    res.write(`data: ${JSON.stringify(chunk)}\\n\\n`);
+                  }
+                }
+              });
+              
+              // Send completion marker
+              if (!res.destroyed) {
+                res.write('data: {"type":"complete"}\\n\\n');
+                res.end();
+              }
+            } catch (error) {
+              if (!res.destroyed) {
+                res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\\n\\n`);
+                res.end();
+              }
             }
+            
+            this.activeConnections.delete(res);
           }
-          
-          this.activeConnections.delete(res);
+        } else {
+          return res.status(500).json({ error: 'No execution runtime available' });
         }
 
       } catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vutler-nexus",
-  "version": "1.0.0",
-  "description": "Vutler Nexus \u2014 Complete local agent runtime with multi-provider LLM support",
+  "version": "2.0.0",
+  "description": "Vutler Nexus — Complete agent runtime with Local (Claude CLI) or Cloud (Vutler API) support",
   "main": "lib/tunnel.js",
   "bin": {
     "vutler-nexus": "./bin/cli.js"
@@ -33,7 +33,8 @@
     "multi-provider",
     "claude",
     "openai",
-    "ollama"
+    "cloud",
+    "vutler-api"
   ],
   "license": "UNLICENSED",
   "files": [
@@ -44,4 +45,4 @@
   "engines": {
     "node": ">=16.0.0"
   }
-}
+}