feat(clone): Phase 2 — DB-backed definition edit path for manual_entry clones

Autonomous decisions:
- Reused UpdateServerInConfigBody { entry } for the bridge/Tauri API — same MCP mcpServers shape the editor already emits
- Parsed entry via UserServerEntry::to_server_definition and preserved non-editable registry metadata from the existing cached row
- Exported canEditServerDefinition from ServerDefinitionModal for ServersPage — single gate for edit affordance and save routing
- Added PUT /spaces/{id}/servers/{id}/definition REST route — DB write is not a spaces/*.json mutation

Signed-off-by: crimsonsunset <jsangio1@gmail.com>

Author: crimsonsunset

apps/desktop/src-tauri/src/commands/space.rs

@@ -7,7 +7,8 @@
 //! viewing in its own Zustand store (frontend-only state).
 
 use mcpmux_core::{
-    validate_workspace_root, Space, SpaceBaseDir, UserServerEntry, WorkspaceRootValidation,
+    application::ServerAppService, validate_workspace_root, InstalledServer, Space, SpaceBaseDir,
+    UserServerEntry, WorkspaceRootValidation,
 };
 use std::sync::Arc;
 use tauri::{AppHandle, State};
@@ -337,6 +338,31 @@ pub async fn update_server_in_config(
     Ok(())
 }
 
+/// Persist a manual-entry clone's definition to `installed_servers.cached_definition`.
+#[tauri::command]
+pub async fn update_cloned_server_definition(
+    app_service: State<'_, Arc<RwLock<Option<ServerAppService>>>>,
+    space_id: String,
+    server_id: String,
+    entry: serde_json::Value,
+) -> Result<InstalledServer, String> {
+    if !entry.is_object() {
+        return Err("Server entry must be a JSON object".to_string());
+    }
+
+    let service_lock = app_service.read().await;
+    let service = service_lock
+        .as_ref()
+        .ok_or("ServerAppService not initialized")?;
+
+    let space_uuid = Uuid::parse_str(&space_id).map_err(|e| e.to_string())?;
+
+    service
+        .update_definition(space_uuid, &server_id, entry)
+        .await
+        .map_err(|e| e.to_string())
+}
+
 /// Refresh the system tray menu to reflect current spaces
 #[tauri::command]
 pub async fn refresh_tray_menu(app: AppHandle, state: State<'_, AppState>) -> Result<(), String> {

apps/desktop/src-tauri/src/lib.rs

@@ -972,6 +972,7 @@ pub fn run() {
             commands::save_space_config,
             commands::remove_server_from_config,
             commands::update_server_in_config,
+            commands::update_cloned_server_definition,
             commands::refresh_tray_menu,
             // Server Discovery commands (v2)
             commands::discover_servers,

apps/desktop/src/components/ServerDefinitionModal.tsx

@@ -3,12 +3,13 @@ import { useTranslation } from 'react-i18next';
 import { X, Copy, Check, Loader2, Save } from 'lucide-react';
 import type { ServerViewModel, ServerDefinition } from '../types/registry';
 import { MonacoJsonEditor } from './monaco-json-editor.component';
-import { updateServerInConfig } from '@/lib/api/spaces';
+import { updateClonedServerDefinition, updateServerInConfig } from '@/lib/api/spaces';
 
 const EDITOR_MOUNT_TIMEOUT_MS = 10_000;
 
 interface ServerDefinitionModalProps {
   server: ServerViewModel;
+  spaceId?: string;
   onClose: () => void;
   /** Called after a successful save so the caller can reload the server list. */
   onSaved?: () => void;
@@ -68,7 +69,19 @@ function buildEditableEntry(server: ServerViewModel): Record<string, unknown> {
   return entry;
 }
 
-export function ServerDefinitionModal({ server, onClose, onSaved }: ServerDefinitionModalProps) {
+/** Whether the Definition editor allows in-place edits for this server. */
+export function canEditServerDefinition(server: ServerViewModel): boolean {
+  return (
+    server.source.type === 'UserSpace' || server.installation_source?.type === 'manual_entry'
+  );
+}
+
+export function ServerDefinitionModal({
+  server,
+  spaceId,
+  onClose,
+  onSaved,
+}: ServerDefinitionModalProps) {
   const { t } = useTranslation('servers');
   const [copied, setCopied] = useState(false);
   const [editorReady, setEditorReady] = useState(false);
@@ -77,7 +90,7 @@ export function ServerDefinitionModal({ server, onClose, onSaved }: ServerDefini
   const [isSaving, setIsSaving] = useState(false);
   const [saveError, setSaveError] = useState<string | null>(null);
 
-  const isEditable = server.source.type === 'UserSpace';
+  const isEditable = canEditServerDefinition(server);
   const [content, setContent] = useState(() =>
     JSON.stringify(isEditable ? buildEditableEntry(server) : extractDefinition(server), null, 2),
   );
@@ -150,22 +163,32 @@ export function ServerDefinitionModal({ server, onClose, onSaved }: ServerDefini
       return;
     }
 
-    if (server.source.type !== 'UserSpace') {
+    if (!isEditable) {
       return;
     }
 
     setIsSaving(true);
     setSaveError(null);
     try {
-      await updateServerInConfig(server.source.space_id, server.id, parsed);
+      if (server.installation_source?.type === 'manual_entry') {
+        if (!spaceId) {
+          setSaveError('Space ID is required to save this definition');
+          return;
+        }
+        await updateClonedServerDefinition(spaceId, server.id, parsed);
+      } else if (server.source.type === 'UserSpace') {
+        await updateServerInConfig(server.source.space_id, server.id, parsed);
+      } else {
+        return;
+      }
       onSaved?.();
       onClose();
     } catch (e) {
       setSaveError(e instanceof Error ? e.message : String(e));
     } finally {
       setIsSaving(false);
     }
-  }, [content, onClose, onSaved, server, t]);
+  }, [content, isEditable, onClose, onSaved, server, spaceId, t]);
 
   return (
     <div className="fixed inset-0 bg-black/60 backdrop-blur-sm flex items-center justify-center z-50 p-4">

apps/desktop/src/features/servers/ServersPage.tsx

@@ -71,7 +71,7 @@ import type {
 import type { FeaturesUpdatedEvent } from '@/lib/api/serverManager';
 import { ServerLogViewer } from '@/components/ServerLogViewer';
 import { ConfigEditorModal } from '@/components/ConfigEditorModal';
-import { ServerDefinitionModal } from '@/components/ServerDefinitionModal';
+import { ServerDefinitionModal, canEditServerDefinition } from '@/components/ServerDefinitionModal';
 import { SourceBadge } from '@/components/SourceBadge';
 import type { ClonedInstalledServer } from '@/lib/api/serverClone';
 import { listCloneDependents } from '@/lib/api/serverClone';
@@ -1964,7 +1964,7 @@ export function ServersPage() {
                         onLockToCurrentVersion={() => handleLockToCurrentVersion(server)}
                         onViewLogs={() => setLogViewerServer({ id: server.id, name: server.name })}
                         onViewDefinition={() => setDefinitionServer({ id: server.id, name: server.name })}
-                        canEditDefinition={server.source.type === 'UserSpace'}
+                        canEditDefinition={canEditServerDefinition(server)}
                         onCloneAccount={() =>
                           setCloneModalServer(resolveCloneSource(server, installedServers))
                         }
@@ -2680,6 +2680,7 @@ export function ServersPage() {
         return server ? (
           <ServerDefinitionModal
             server={server}
+            spaceId={viewSpace?.id}
             onClose={() => setDefinitionServer(null)}
             onSaved={() => loadData()}
           />

apps/desktop/src/lib/api/spaces.ts

@@ -72,6 +72,18 @@ export async function updateServerInConfig(
   return apiCall('update_server_in_config', { spaceId, serverId, entry });
 }
 
+/**
+ * Persist a manual-entry clone's definition to `installed_servers.cached_definition`.
+ * `entry` uses the same standard MCP format as `updateServerInConfig`.
+ */
+export async function updateClonedServerDefinition(
+  spaceId: string,
+  serverId: string,
+  entry: Record<string, unknown>,
+): Promise<void> {
+  return apiCall('update_cloned_server_definition', { spaceId, serverId, entry });
+}
+
 /** Reveal a space config file in the system editor (desktop only). */
 export async function openSpaceConfigFile(spaceId: string): Promise<void> {
   return shellOpenSpaceConfigFile(spaceId);

apps/desktop/src/lib/backend/data/fetch-api.routes/spaces.routes.ts

@@ -46,6 +46,11 @@ export const spacesRoutes: Record<string, RouteHandler> = {
     path: `/api/v1/spaces/${encodeURIComponent(String(args.spaceId))}/config/servers/${encodeURIComponent(String(args.serverId))}`,
     body: { entry: args.entry },
   }),
+  update_cloned_server_definition: (args) => ({
+    method: 'PUT',
+    path: `/api/v1/spaces/${encodeURIComponent(String(args.spaceId))}/servers/${encodeURIComponent(String(args.serverId))}/definition`,
+    body: { entry: args.entry },
+  }),
   list_space_base_dirs: (args) => ({
     method: 'GET',
     path: `/api/v1/spaces/${encodeURIComponent(String(args.spaceId))}/base-dirs`,

crates/mcpmux-core/src/application/server.rs

@@ -368,6 +368,93 @@ impl ServerAppService {
         Ok(updated)
     }
 
+    /// Update the cached definition for a manual-entry installed server.
+    ///
+    /// Accepts the standard MCP `mcpServers` entry shape from the Definition editor.
+    /// Rejects servers whose `installation_source` is not `ManualEntry`.
+    ///
+    /// Emits: `ServerConfigUpdated`
+    pub async fn update_definition(
+        &self,
+        space_id: Uuid,
+        server_id: &str,
+        entry: serde_json::Value,
+    ) -> Result<InstalledServer> {
+        if !entry.is_object() {
+            return Err(anyhow!("Server entry must be a JSON object"));
+        }
+
+        let space_id_str = space_id.to_string();
+
+        let server = self
+            .server_repo
+            .get_by_server_id(&space_id_str, server_id)
+            .await?
+            .ok_or_else(|| anyhow!("Server not installed"))?;
+
+        if server.source != InstallationSource::ManualEntry {
+            return Err(anyhow!(
+                "Definition updates via this path require installation_source ManualEntry"
+            ));
+        }
+
+        let existing = server
+            .get_definition()
+            .ok_or_else(|| anyhow!("Server has no cached definition"))?;
+
+        let user_entry: UserServerEntry = serde_json::from_value(entry)
+            .map_err(|e| anyhow!("Invalid server entry: {}", e))?;
+
+        let mut definition = user_entry.to_server_definition(
+            server_id,
+            &space_id_str,
+            std::path::PathBuf::new(),
+        );
+
+        definition.id = existing.id.clone();
+        definition.source = ServerSource::ManualEntry;
+        definition.categories = existing.categories.clone();
+        definition.badges = existing.badges.clone();
+        definition.hosting_type = existing.hosting_type;
+        definition.license = existing.license.clone();
+        definition.license_url = existing.license_url.clone();
+        definition.installation = existing.installation.clone();
+        definition.capabilities = existing.capabilities.clone();
+        definition.sponsored = existing.sponsored.clone();
+        definition.media = existing.media.clone();
+        definition.changelog_url = existing.changelog_url.clone();
+        if definition.publisher.is_none() {
+            definition.publisher = existing.publisher.clone();
+        }
+
+        let cached_def = serde_json::to_string(&definition)
+            .map_err(|e| anyhow!("Failed to serialize definition: {}", e))?;
+
+        self.server_repo
+            .update_cached_definition(
+                &server.id,
+                Some(definition.name.clone()),
+                Some(cached_def.clone()),
+            )
+            .await?;
+
+        info!(
+            space_id = %space_id,
+            server_id = server_id,
+            "[ServerAppService] Updated manual-entry server definition"
+        );
+
+        self.event_sender.emit(DomainEvent::ServerConfigUpdated {
+            space_id,
+            server_id: server_id.to_string(),
+        });
+
+        let mut updated = server;
+        updated.cached_definition = Some(cached_def);
+        updated.server_name = Some(definition.name);
+        Ok(updated)
+    }
+
     /// Clone an existing installed server into a new server ID with the given suffix.
     ///
     /// Emits: `ServerInstalled`

crates/mcpmux-gateway/src/admin/command_bridge/space.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 use anyhow::{Context, Result};
 use mcpmux_core::{get_space_config_path, ApplicationServices, Space, UserServerEntry};
 use serde::Deserialize;
+use serde_json::Value;
 use tracing::info;
 use uuid::Uuid;
 
@@ -195,6 +196,21 @@ pub async fn update_server_in_config(
     Ok(())
 }
 
+/// Persist a manual-entry clone's definition to `installed_servers.cached_definition`.
+pub async fn update_cloned_server_definition(
+    ctx: &SpaceBridgeCtx<'_>,
+    space_id: &str,
+    server_id: &str,
+    entry: Value,
+) -> Result<()> {
+    let space_uuid = Uuid::parse_str(space_id)?;
+    ctx.services
+        .server()
+        .update_definition(space_uuid, server_id, entry)
+        .await?;
+    Ok(())
+}
+
 fn write_default_config_if_missing(ctx: &SpaceBridgeCtx<'_>, space_id: &str) -> Result<()> {
     std::fs::create_dir_all(ctx.spaces_dir)
         .with_context(|| format!("Failed to create spaces dir: {}", ctx.spaces_dir.display()))?;

crates/mcpmux-gateway/src/admin/command_bridge/write.rs

@@ -455,6 +455,17 @@ pub async fn update_server_in_config(
     Ok(json!({ "ok": true }))
 }
 
+pub async fn update_cloned_server_definition(
+    ctx: &AdminBridgeCtx,
+    space_id: String,
+    server_id: String,
+    body: UpdateServerInConfigBody,
+) -> Result<Value> {
+    space::update_cloned_server_definition(&space_ctx(ctx), &space_id, &server_id, body.entry)
+        .await?;
+    Ok(json!({ "ok": true }))
+}
+
 // --- Feature sets ---
 
 pub async fn create_feature_set(ctx: &AdminBridgeCtx, body: CreateFeatureSetBody) -> Result<Value> {

crates/mcpmux-gateway/src/admin/handlers/write.rs

@@ -109,6 +109,17 @@ pub async fn update_server_in_config(
         .map_err(ApiError::from_bridge)
 }
 
+pub async fn update_cloned_server_definition(
+    State(state): State<AdminState>,
+    Path((space_id, server_id)): Path<(String, String)>,
+    Json(body): Json<UpdateServerInConfigBody>,
+) -> Result<Json<Value>, ApiError> {
+    bridge::update_cloned_server_definition(&state.bridge, space_id, server_id, body)
+        .await
+        .map(ok)
+        .map_err(ApiError::from_bridge)
+}
+
 pub async fn start_gateway(
     State(state): State<AdminState>,
     Json(body): Json<GatewayStartBody>,