changes to port selecting & settings

Author: ZahinTapadar

src-tauri/src/lib.rs

@@ -3,11 +3,32 @@ use std::path::Path;
 use std::net::TcpStream;
 use std::time::Duration;
 use serde_json::json;
-use regex::Regex;
 
 #[cfg(target_os = "windows")]
 use std::os::windows::process::CommandExt;
 
+// Default Ollama port
+const DEFAULT_OLLAMA_PORT: u16 = 11434;
+
+// Helper function to get Ollama port from environment or use default
+fn get_ollama_port() -> u16 {
+    std::env::var("OLLAMA_PORT")
+        .ok()
+        .and_then(|s| s.parse::<u16>().ok())
+        .unwrap_or(DEFAULT_OLLAMA_PORT)
+}
+
+// Helper function to get Ollama base URL
+fn get_ollama_base_url() -> String {
+    let port = get_ollama_port();
+    format!("http://localhost:{}", port)
+}
+
+// Helper function to get Ollama API endpoint
+fn get_ollama_api_url(endpoint: &str) -> String {
+    format!("{}/api/{}", get_ollama_base_url(), endpoint)
+}
+
 // Helper function to generate extended PATH based on platform
 fn get_extended_path() -> String {
     let current_path = std::env::var("PATH").unwrap_or_default();
@@ -53,11 +74,33 @@ fn get_platform() -> String {
     }
 }
 
+#[tauri::command]
+fn get_ollama_port_config() -> u16 {
+    get_ollama_port()
+}
+
+#[tauri::command]
+fn set_ollama_port_config(port: u16) -> Result<String, String> {
+    if port < 1024 || port > 65535 {
+        return Err("Port must be between 1024 and 65535".to_string());
+    }
+    
+    std::env::set_var("OLLAMA_PORT", port.to_string());
+    Ok(format!("Ollama port set to {}", port))
+}
+
+#[tauri::command]
+fn get_ollama_url() -> String {
+    get_ollama_base_url()
+}
+
 #[tauri::command]
 fn check_ollama_service_running() -> bool {
-    // Check if Ollama service is running by attempting to connect to port 11434
+    // Check if Ollama service is running by attempting to connect to the configured port
+    let port = get_ollama_port();
+    let address = format!("127.0.0.1:{}", port);
     TcpStream::connect_timeout(
-        &"127.0.0.1:11434".parse().unwrap(),
+        &address.parse().unwrap(),
         Duration::from_millis(1000)
     ).is_ok()
 }
@@ -366,8 +409,9 @@ async fn list_installed_models() -> Result<Vec<String>, String> {
                 // If ollama list fails, try to use the API directly
                 if cfg!(target_os = "windows") {
                     // On Windows, try to use curl to call the API
+                    let api_url = get_ollama_api_url("tags");
                     let api_result = Command::new("curl")
-                        .args(["-s", "http://localhost:11434/api/tags"])
+                        .args(["-s", &api_url])
                         .output();
 
                     match api_result {
@@ -603,10 +647,11 @@ async fn stop_ollama_service() -> Result<String, String> {
 #[tauri::command]
 async fn load_ollama_model(model_name: String) -> Result<String, String> {
     // Load a model by making a simple request to it
+    let api_url = get_ollama_api_url("generate");
     let output = Command::new("curl")
         .args([
             "-X", "POST",
-            "http://localhost:11434/api/generate",
+            &api_url,
             "-H", "Content-Type: application/json",
             "-d", &format!(r#"{{"model": "{}", "prompt": "hello", "stream": false}}"#, model_name)
         ])
@@ -620,7 +665,7 @@ async fn load_ollama_model(model_name: String) -> Result<String, String> {
                 if stdout.contains("error") {
                     Err(format!("Failed to load model '{}': {}", model_name, stdout))
                 } else {
-                    Ok(format!("Model '{}' loaded successfully. API Response received. Command: curl -X POST http://localhost:11434/api/generate", model_name))
+                    Ok(format!("Model '{}' loaded successfully. API Response received. Command: curl -X POST {}", model_name, api_url))
                 }
             } else {
                 let error = String::from_utf8_lossy(&output.stderr);
@@ -732,18 +777,19 @@ async fn scan_for_models() -> Result<Vec<String>, String> {
 
 #[tauri::command]
 fn check_ollama_service_status() -> Result<bool, String> {
-    // Primary method: Check if Ollama service is running by testing TCP connection to port 11434
+    // Primary method: Check if Ollama service is running by testing TCP connection to the configured port
     if check_ollama_service_running() {
         return Ok(true);
     }
 
     // Secondary method: Try to call the API directly
+    let api_url = get_ollama_api_url("tags");
     let output = Command::new("curl")
         .args([
             "-s",
             "--connect-timeout", "2",
             "--max-time", "3",
-            "http://localhost:11434/api/tags"
+            &api_url
         ])
         .output();
 
@@ -884,7 +930,7 @@ async fn fix_windows_ollama_service() -> Result<String, String> {
                 attempts += 1;
             }
 
-            fix_info.push_str("   ⚠ Service was started but is not responding on port 11434\n");
+            fix_info.push_str(&format!("   ⚠ Service was started but is not responding on port {}\n", get_ollama_port()));
             fix_info.push_str("   Try restarting the app or running 'ollama serve' manually\n");
 
             Err(fix_info)
@@ -1451,7 +1497,10 @@ pub fn run() {
         diagnose_windows_ollama_issues,
         fix_windows_ollama_service,
         ask_ollama_verbose,
-        search_web
+        search_web,
+        get_ollama_port_config,
+        set_ollama_port_config,
+        get_ollama_url
     ])
     .setup(|app| {
       if cfg!(debug_assertions) {

src/app/services/ollamaService.ts

@@ -1,5 +1,44 @@
 import { invoke } from '@tauri-apps/api/core';
 
+// Custom port management
+let cachedPort: number | null = null;
+
+export async function getOllamaPort(): Promise<number> {
+  if (cachedPort === null) {
+    try {
+      cachedPort = await invoke('get_ollama_port_config') as number;
+    } catch (error) {
+      console.warn('Failed to get Ollama port from backend, using default:', error);
+      cachedPort = 11434;
+    }
+  }
+  return cachedPort;
+}
+
+export function clearPortCache(): void {
+  cachedPort = null;
+}
+
+export async function setOllamaPort(port: number): Promise<string> {
+  try {
+    const result = await invoke('set_ollama_port_config', { port }) as string;
+    cachedPort = port; // Update cache
+    return result;
+  } catch (error: any) {
+    throw new Error(`Failed to set Ollama port: ${error.message || error}`);
+  }
+}
+
+export async function getOllamaBaseUrl(): Promise<string> {
+  try {
+    return await invoke('get_ollama_url') as string;
+  } catch (error) {
+    // Fallback to constructing URL from port
+    const port = await getOllamaPort();
+    return `http://localhost:${port}`;
+  }
+}
+
 // Streaming Ollama wrapper for real-time text generation
 export async function askOllamaStreaming(
   prompt: string, 
@@ -18,7 +57,8 @@ export async function askOllamaStreaming(
       stream: true 
     };
 
-    const res = await fetch("http://localhost:11434/api/generate", {
+    const baseUrl = await getOllamaBaseUrl();
+    const res = await fetch(`${baseUrl}/api/generate`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(requestBody),
@@ -77,7 +117,8 @@ export async function askOllama(
       requestBody.images = images;
     }
 
-    const res = await fetch("http://localhost:11434/api/generate", {
+    const baseUrl = await getOllamaBaseUrl();
+    const res = await fetch(`${baseUrl}/api/generate`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(requestBody),
@@ -124,7 +165,8 @@ export async function askOllama(
 export async function listOllamaModels(): Promise<string[]> {
   try {
     // Primary method: Try the API directly
-    const res = await fetch("http://localhost:11434/api/tags", {
+    const baseUrl = await getOllamaBaseUrl();
+    const res = await fetch(`${baseUrl}/api/tags`, {
       method: "GET",
       signal: AbortSignal.timeout(5000), // 5 second timeout
     });
@@ -198,7 +240,8 @@ export async function forceRefreshModels(): Promise<string[]> {
   try {
     // On Windows, sometimes we need to force a refresh of the Ollama connection
     // First, try to "wake up" Ollama by making a simple API call
-    await fetch("http://localhost:11434/api/tags", {
+    const baseUrl = await getOllamaBaseUrl();
+    await fetch(`${baseUrl}/api/tags`, {
       method: "GET",
       signal: AbortSignal.timeout(3000),
     }).catch(() => {}); // Ignore errors, this is just to wake up the service
@@ -244,7 +287,8 @@ export interface DownloadProgress {
 export async function checkOllamaStatus(): Promise<OllamaStatus> {
   try {
     // Primary method: Try to connect to Ollama API using standard fetch
-    const res = await fetch("http://localhost:11434/api/tags", {
+    const baseUrl = await getOllamaBaseUrl();
+    const res = await fetch(`${baseUrl}/api/tags`, {
       method: "GET",
       signal: AbortSignal.timeout(3000), // 3 second timeout
     });

src/components/Chat.tsx

@@ -2,18 +2,19 @@
 
 import { useState, useEffect, useRef, useCallback } from "react";
 import { useTheme } from "next-themes";
-import { askOllama, listOllamaModels, forceRefreshModels, checkOllamaStatus, askOllamaVerbose, askOllamaStreaming, searchWeb, type OllamaStatus } from "@/app/services/ollamaService";
+import { askOllama, listOllamaModels, forceRefreshModels, checkOllamaStatus, askOllamaVerbose, askOllamaStreaming, searchWeb, clearPortCache, type OllamaStatus } from "@/app/services/ollamaService";
 import { PlaceholdersAndVanishInput } from "@/components/ui/placeholders-and-vanish-input";
 import { TextGenerateEffect } from "@/components/ui/enhanced-text-generate-effect";
 import { StreamingTextEffect } from "@/components/ui/streaming-text-effect";
 import { MarkdownRenderer } from "@/components/MarkdownRenderer";
 import { ThinkingRenderer } from "@/components/ThinkingRenderer";
 import { Button } from "@/components/ui/button";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
-import { MessageSquare, Bot, User, Plus, MoreHorizontal, Menu, Sun, Moon, Trash2, X, Settings, Terminal, Eye, EyeOff, RefreshCw, BarChart3, Search } from "lucide-react";
+import { MessageSquare, Bot, User, Plus, MoreHorizontal, Menu, Sun, Moon, Trash2, X, Settings as SettingsIcon, Terminal, Eye, EyeOff, RefreshCw, BarChart3, Search } from "lucide-react";
 import { ShineBorder } from "@/components/magicui/shine-border";
 import { OllamaChatIcon } from "@/components/ui/ollama-chat-icon";
 import { OllamaSetupOverlay } from "@/components/OllamaSetupOverlay";
+import { Settings } from "@/components/Settings";
 
 interface Message {
   id: string;
@@ -62,6 +63,7 @@ export default function Chat() {
   const [openMenuId, setOpenMenuId] = useState<string | null>(null);
   const [ollamaStatus, setOllamaStatus] = useState<OllamaStatus>({ isInstalled: false, isRunning: false });
   const [showOllamaSetup, setShowOllamaSetup] = useState(false);
+  const [showSettings, setShowSettings] = useState(false);
   const [commandLogs, setCommandLogs] = useState<CommandLog[]>([]);
   const [showLogs, setShowLogs] = useState(false);
   const [clearConfirmation, setClearConfirmation] = useState<ClearConfirmationState>({
@@ -761,6 +763,23 @@ export default function Chat() {
     }
   }, [refreshModels]);
 
+  const handlePortChanged = useCallback(async () => {
+    // When the port changes, refresh Ollama status and models to use the new port
+    try {
+      // Clear cached port to force re-fetch from backend
+      clearPortCache();
+      
+      const status = await checkOllamaStatus();
+      setOllamaStatus(status);
+      
+      if (status.isRunning) {
+        await refreshModels();
+      }
+    } catch (error) {
+      console.error('Error updating status after port change:', error);
+    }
+  }, [refreshModels]);
+
   const handleStatsRequest = async () => {
     // Toggle verbose mode for future messages
     setVerboseMode(!verboseMode);
@@ -943,10 +962,10 @@ export default function Chat() {
               <Button
                 variant="ghost"
                 size="sm"
-                onClick={() => setShowOllamaSetup(true)}
-                title="Ollama Settings"
+                onClick={() => setShowSettings(true)}
+                title="Settings"
               >
-                <Settings className="w-4 h-4" />
+                <SettingsIcon className="w-4 h-4" />
               </Button>
               <Button
                 variant="ghost"
@@ -1477,6 +1496,14 @@ export default function Chat() {
         onCommandLog={addCommandLog}
         onCommandUpdate={updateCommandLog}
       />
+
+      {/* Settings Modal */}
+      <Settings
+        isOpen={showSettings}
+        onClose={() => setShowSettings(false)}
+        onPortChanged={handlePortChanged}
+        onOllamaStatusChange={handleOllamaStatusChange}
+      />
     </div>
   );
 }