import { useState, useEffect, useCallback, useRef } from 'react'; import { RefreshCw, ExternalLink, Zap, Play, Square, Copy, Check, ChevronDown, ChevronRight, } from 'lucide-react'; import { Button } from '../../ui/button'; import { Input } from '../../ui/input'; import { setConfigProvider, updateCustomProvider, createCustomProvider, getCustomProvider, } from '../../../api'; import { useModelAndProvider } from '../../ModelAndProviderContext'; const MESH_API_PORT = 9337; const MESH_CONSOLE_PORT = 3131; const MESH_DEFAULT_MODEL = 'Qwen3-30B-A3B-Q4_K_M'; // Popular models from mesh-llm catalog, grouped by size const MODEL_CATALOG = [ { name: 'Qwen3-4B-Q4_K_M', size: '~3 GB', tier: 'small' }, { name: 'Qwen3-8B-Q4_K_M', size: '~5 GB', tier: 'small' }, { name: 'Qwen3-14B-Q4_K_M', size: '~9 GB', tier: 'medium' }, { name: 'Devstral-Small-2505-Q4_K_M', size: '~14 GB', tier: 'medium' }, { name: 'Qwen3-30B-A3B-Q4_K_M', size: '~17 GB', tier: 'large' }, { name: 'GLM-4.7-Flash-Q4_K_M', size: '~17 GB', tier: 'large' }, { name: 'Qwen3-32B-Q4_K_M', size: '~20 GB', tier: 'large' }, { name: 'Qwen2.5-Coder-32B-Instruct-Q4_K_M', size: '~20 GB', tier: 'large' }, { name: 'Qwen2.5-72B-Instruct-Q4_K_M', size: '~42 GB', tier: 'xlarge' }, ]; type MeshMode = 'new' | 'join' | 'auto'; type MeshStatus = 'unknown' | 'running' | 'stopped' | 'starting' | 'not-installed' | 'downloading'; interface MeshStatusInfo { running: boolean; installed: boolean; models: string[]; token?: string; peerCount?: number; nodeStatus?: string; binaryPath?: string; } export const MeshSettings = () => { const { refreshCurrentModelAndProvider } = useModelAndProvider(); const isMacOS = window.electron.platform === 'darwin' && window.electron.arch === 'arm64'; const [status, setStatus] = useState('unknown'); const [statusInfo, setStatusInfo] = useState({ running: false, installed: true, models: [], }); const [mode, setMode] = useState('auto'); const [selectedModel, setSelectedModel] = useState(MESH_DEFAULT_MODEL); const [joinToken, setJoinToken] = useState(''); const [contributeGpu, setContributeGpu] = useState(false); const [copiedToken, setCopiedToken] = useState(false); const [showAdvanced, setShowAdvanced] = useState(false); const [saving, setSaving] = useState(false); const [error, setError] = useState(null); const [activeModel, setActiveModel] = useState(null); const [meshProviderId, setMeshProviderIdState] = useState( () => localStorage.getItem('mesh-provider-id') ?? 'mesh' ); const setMeshProviderId = (id: string) => { setMeshProviderIdState(id); localStorage.setItem('mesh-provider-id', id); }; const [checking, setChecking] = useState(false); const startTimeoutRef = useRef | null>(null); const checkStatus = useCallback(async () => { setChecking(true); try { const result = await window.electron.checkMesh(); if (result.running) { setStatus('running'); setStatusInfo(result); } else if (!result.installed && !isMacOS) { // On non-macOS, binary must be manually installed. setStatus((prev) => (prev === 'downloading' ? prev : 'not-installed')); setStatusInfo({ running: false, installed: false, models: [] }); } else { // On macOS, start-mesh handles downloading, so treat not-installed as stopped. setStatus((prev) => (prev === 'starting' || prev === 'downloading' ? prev : 'stopped')); setStatusInfo({ ...result, models: [] }); } } catch { setStatus((prev) => (prev === 'starting' || prev === 'downloading' ? prev : 'stopped')); } finally { setChecking(false); } }, [isMacOS]); useEffect(() => { checkStatus(); const interval = setInterval(checkStatus, status === 'starting' ? 3000 : 10000); return () => clearInterval(interval); }, [checkStatus, status]); const meshProviderBody = (models: string[]) => ({ engine: 'openai_compatible' as const, display_name: 'Inference Mesh', api_url: `http://localhost:${MESH_API_PORT}`, api_key: '', models, supports_streaming: true, requires_auth: false, }); // Create or update the mesh custom provider via the REST API, // which handles file writes and registry refresh atomically. // Returns the provider ID to use with setConfigProvider. const ensureMeshProvider = async (models: string[]): Promise => { const modelList = models.length > 0 ? models : [MESH_DEFAULT_MODEL]; const body = meshProviderBody(modelList); // Try the last-known provider ID first, then fall back to 'mesh' const idsToTry = meshProviderId === 'mesh' ? ['mesh'] : [meshProviderId, 'mesh']; for (const id of idsToTry) { const existing = await getCustomProvider({ path: { id } }); if (existing.data) { await updateCustomProvider({ path: { id }, body, throwOnError: true, }); setMeshProviderId(id); return id; } } // Provider doesn't exist yet — create it const result = await createCustomProvider({ body, throwOnError: true, }); const newId = result.data?.provider_name ?? 'mesh'; setMeshProviderId(newId); return newId; }; const activateModel = async (modelId: string) => { setSaving(true); setError(null); try { const providerId = await ensureMeshProvider(statusInfo.models); await setConfigProvider({ body: { provider: providerId, model: modelId }, throwOnError: true, }); await refreshCurrentModelAndProvider(); setActiveModel(modelId); } catch (err) { setError(`Failed to activate model: ${err}`); } finally { setSaving(false); } }; const startMesh = async () => { setError(null); // On macOS, start-mesh downloads the latest binary first. setStatus(isMacOS ? 'downloading' : 'starting'); try { const args: string[] = []; if (mode === 'new') { args.push('serve', '--model', selectedModel); } else if (mode === 'join') { if (!joinToken.trim()) { setError('Paste an invite token to join a mesh'); setStatus('stopped'); return; } if (contributeGpu) { args.push('serve', '--join', joinToken.trim()); } else { args.push('client', '--join', joinToken.trim()); } } else { // auto if (contributeGpu) { args.push('serve', '--auto'); } else { args.push('client', '--auto'); } } const result = await window.electron.startMesh(args); if (!result.started) { setError(result.error || 'Failed to start mesh-llm'); setStatus('stopped'); return; } setStatus('starting'); // Polling will pick up when it's ready. Timeout after 5 min so // the UI doesn't get stuck in "starting" if the daemon crashes. if (startTimeoutRef.current) { clearTimeout(startTimeoutRef.current); } startTimeoutRef.current = setTimeout(() => { startTimeoutRef.current = null; setStatus((prev) => { if (prev === 'starting') { setError('mesh-llm did not become ready. Check ~/.mesh-llm/mesh-llm.log'); return 'stopped'; } return prev; }); }, 300000); } catch (err) { setError(`Failed to start: ${err}`); setStatus('stopped'); } }; const stopMesh = async () => { try { const result = await window.electron.stopMesh(); if (result.stopped) { setStatus('stopped'); setStatusInfo((prev) => ({ ...prev, running: false, models: [], token: undefined })); } else { setError('Failed to stop mesh-llm'); } } catch { setError('Failed to stop mesh-llm'); } }; const copyToken = () => { if (statusInfo.token) { navigator.clipboard.writeText(statusInfo.token); setCopiedToken(true); setTimeout(() => setCopiedToken(false), 2000); } }; const StatusIndicator = () => { switch (status) { case 'running': return ( Running — {statusInfo.models.length} model {statusInfo.models.length !== 1 ? 's' : ''} available {statusInfo.peerCount !== undefined && statusInfo.peerCount > 0 && ( · {statusInfo.peerCount} peer{statusInfo.peerCount !== 1 ? 's' : ''} )} ); case 'starting': return ( Starting — this may take a minute if downloading a model... ); case 'downloading': return ( Downloading latest mesh-llm (~19 MB)... ); case 'not-installed': return ( mesh-llm not installed ); case 'stopped': return ( {checking ? ( ) : ( )} Not running ); default: return checking ? ( Checking... ) : null; } }; return (

{/* Header */}

Inference Mesh

Learn more

Experimental. Pool GPUs with others for decentralized LLM inference — no API keys, no cloud. Start a private mesh, join one with an invite token, or discover public meshes.{' '} docs.anarchai.org

{error &&

{error}

}

{/* Not installed — non-macOS only; on macOS start-mesh handles the download */} {status === 'not-installed' && (

Get started

mesh-llm is not installed. Follow the install guide to set it up, or connect to a mesh already running on this machine.

)} {/* Downloading */} {status === 'downloading' && (

Downloading latest mesh-llm...

Fetching the latest version to ~/.mesh-llm/. This should only take a moment.

)} {/* Setup panel — shown when stopped and installed */} {(status === 'stopped' || status === 'unknown') && (

{/* Mode selector */}

setMode('auto')} />

Auto-discover a public mesh

Find and join the best available mesh automatically.

Public meshes are run by volunteers. Your prompts are sent to their hardware — no privacy guarantees.

setMode('join')} />

Join with invite token

Join a private mesh someone shared with you.

setMode('new')} />

Start a new private mesh

Create your own mesh. Share the invite token with others to pool GPUs.

{/* Mode-specific options */} {mode === 'new' && (

Model to serve

Downloads automatically if not already cached. Larger models need more VRAM.

)} {mode === 'join' && (

Invite token setJoinToken(e.target.value)} placeholder="Paste invite token here" className="max-w-md" />

)} {(mode === 'auto' || mode === 'join') && ( setContributeGpu(e.target.checked)} /> Contribute GPU (serve models for others too) )}

When you start the mesh, keep goose running to stay connected.

)} {/* Starting indicator */} {status === 'starting' && (

Starting mesh-llm...

Connecting to the mesh and loading models. This may take a minute on first run.

)} {/* Running state */} {status === 'running' && ( <> {/* Invite token */} {statusInfo.token && (

Invite token

Share this with others so they can join your mesh.


                {statusInfo.token}

)} {/* Model list */} {statusInfo.models.length > 0 && (

Available Models

Select a model to use it as your Goose provider.

{statusInfo.models.map((modelId) => { const isActive = activeModel === modelId; return (

!saving && activateModel(modelId)} >

{modelId} live

{isActive ? ( Active ) : ( )}

); })}

)} {statusInfo.models.length === 0 && (

Mesh is running but no models are available yet. A model may still be loading.

)}

Keep goose running to stay connected to the mesh.

{/* Actions row */}

Open Console

)} {/* Advanced settings */}

{showAdvanced && (

{statusInfo.binaryPath && (

Binary {statusInfo.binaryPath}

)}

API endpoint http://localhost:{MESH_API_PORT}/v1

Console


                http://localhost:{MESH_CONSOLE_PORT}

)}

{/* Refresh */}

); };