feat(workspaces): group the same project across machines via git remote

Bindings created from different clone paths now share a card by default, with a panel override to force-link or isolate when origin is missing or wrong.

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

Author: crimsonsunset

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

@@ -8,10 +8,11 @@ use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 use mcpmux_core::{
-    normalize_optional_metadata, validate_workspace_root as validate_root, BindingType,
-    DomainEvent, FeatureSet, FeatureSetType, MemberMode, MemberType, ServerFeature,
-    WorkspaceBinding, WorkspaceRootValidation,
+    normalize_optional_metadata, resolve_persisted_override,
+    validate_workspace_root as validate_root, BindingType, DomainEvent, FeatureSet, FeatureSetType,
+    MemberMode, MemberType, ServerFeature, WorkspaceBinding, WorkspaceRootValidation,
 };
+use mcpmux_gateway::services::{apply_detected_git_remote, detect_origin_remote};
 use mcpmux_storage::InboundClientRepository;
 use serde::{Deserialize, Serialize};
 use tauri::State;
@@ -79,6 +80,10 @@ pub struct WorkspaceBindingDto {
     pub machine_id: Option<String>,
     #[serde(default)]
     pub binding_type: Option<String>,
+    #[serde(default)]
+    pub git_remote_url: Option<String>,
+    #[serde(default)]
+    pub project_link_id: Option<String>,
     pub created_at: String,
     pub updated_at: String,
 }
@@ -94,6 +99,8 @@ impl From<WorkspaceBinding> for WorkspaceBindingDto {
             feature_set_ids: b.feature_set_ids,
             machine_id: b.machine_id.map(|id| id.to_string()),
             binding_type: Some(b.binding_type.as_db_str().to_string()),
+            git_remote_url: b.git_remote_url,
+            project_link_id: b.project_link_id,
             created_at: b.created_at.to_rfc3339(),
             updated_at: b.updated_at.to_rfc3339(),
         }
@@ -116,6 +123,10 @@ pub struct WorkspaceBindingInput {
     pub machine_id: Option<String>,
     #[serde(default)]
     pub binding_type: Option<String>,
+    #[serde(default)]
+    pub git_remote_url: Option<String>,
+    #[serde(default)]
+    pub project_link_id: Option<String>,
 }
 
 fn parse_optional_machine_id(value: Option<&str>) -> Result<Option<Uuid>, String> {
@@ -352,6 +363,18 @@ pub async fn list_workspace_bindings_for_space(
         .map_err(|e| e.to_string())
 }
 
+/// Best-effort `origin` remote for a folder. `None` when the path isn't a
+/// git clone, git isn't on PATH, or detection times out.
+#[tauri::command]
+pub async fn detect_workspace_git_remote(path: String) -> Result<Option<String>, String> {
+    let normalized = match validate_root(&path) {
+        WorkspaceRootValidation::Empty => return Ok(None),
+        WorkspaceRootValidation::Ok { normalized } => normalized,
+        WorkspaceRootValidation::Invalid { reason } => return Err(reason),
+    };
+    Ok(detect_origin_remote(std::path::Path::new(&normalized)).await)
+}
+
 /// Live path validation for the UI — returns `Ok(normalized)` or
 /// `Err(reason)`. Runs the same rules the create/update commands apply, so
 /// the form can show the real error message without round-tripping a save.
@@ -398,22 +421,28 @@ pub async fn create_workspace_binding(
         binding.machine_id = machine_id;
         binding.label = resolve_binding_label(&input, None);
         binding.icon = normalize_optional_metadata(&input.icon);
+        binding.git_remote_url = resolve_persisted_override(input.git_remote_url.as_deref(), None);
+        binding.project_link_id =
+            resolve_persisted_override(input.project_link_id.as_deref(), None);
         (client_key.to_string(), binding)
     } else {
         let normalized = normalize_and_validate(&input.workspace_root)?;
-        let binding = WorkspaceBinding {
+        let mut binding = WorkspaceBinding {
             id: Uuid::new_v4(),
             workspace_root: normalized.clone(),
             binding_type: BindingType::Path,
             client_id: None,
             machine_id,
             label: resolve_binding_label(&input, None),
             icon: resolve_binding_icon(&state, &normalized, &input, None).await?,
+            git_remote_url: resolve_persisted_override(input.git_remote_url.as_deref(), None),
+            project_link_id: resolve_persisted_override(input.project_link_id.as_deref(), None),
             space_id,
             feature_set_ids,
             created_at: chrono::Utc::now(),
             updated_at: chrono::Utc::now(),
         };
+        apply_detected_git_remote(&mut binding).await;
         (normalized, binding)
     };
 
@@ -539,6 +568,14 @@ pub async fn update_workspace_binding(
         machine_id,
         label,
         icon,
+        git_remote_url: resolve_persisted_override(
+            input.git_remote_url.as_deref(),
+            existing.git_remote_url.clone(),
+        ),
+        project_link_id: resolve_persisted_override(
+            input.project_link_id.as_deref(),
+            existing.project_link_id.clone(),
+        ),
         space_id,
         feature_set_ids,
         created_at: existing.created_at,

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

@@ -1031,6 +1031,7 @@ pub fn run() {
             commands::is_workspace_binding_prompt_dismissed,
             commands::delete_workspace_binding,
             commands::validate_workspace_root,
+            commands::detect_workspace_git_remote,
             commands::get_workspace_effective_features,
             // Per-workspace MCP client config install (X-Mcpmux-Workspace header)
             commands::list_workspace_install_clients,

apps/desktop/src/features/workspaces/WorkspacesPage.tsx

@@ -84,7 +84,7 @@ import {
 } from '@/stores';
 import type { Space } from '@/lib/api/spaces';
 import { FormField } from './workspace-binding-form.component';
-import { formatFsList } from './workspace-binding-form.helpers';
+import { formatFsList, projectKey } from './workspace-binding-form.helpers';
 import { EmojiPickerButton } from '@/components/emoji-picker-button.component';
 import { useViewerIdentity } from '@/hooks/use-viewer-identity.hook';
 
@@ -110,12 +110,60 @@ interface Entry {
   id: string;
   kind: EntryKind;
   root: string;
+  /** Every distinct root folded into this card (1 unless project-linked). */
+  roots: string[];
   bindings: WorkspaceBinding[];
   isLive: boolean;
   /** Id-type bindings route by OAuth/API client id, not folder path. */
   isClientMapping?: boolean;
 }
 
+const ENTRY_KIND_RANK: Record<EntryKind, number> = {
+  'unmapped-live': 0,
+  'live-elsewhere': 1,
+  'mapped-live': 2,
+  'mapped-offline': 3,
+};
+
+/**
+ * Fold root-level entries that share a project key into one card.
+ */
+function mergeByProjectKey(rootEntries: Entry[]): Entry[] {
+  const byKey = new Map<string, Entry[]>();
+  const standalone: Entry[] = [];
+  for (const entry of rootEntries) {
+    const key = entry.bindings.map(projectKey).find((k) => k != null) ?? null;
+    if (key == null) {
+      standalone.push({ ...entry, roots: entry.roots.length > 0 ? entry.roots : [entry.root] });
+      continue;
+    }
+    const group = byKey.get(key) ?? [];
+    group.push(entry);
+    byKey.set(key, group);
+  }
+  const merged = [...byKey.values()].map((group) => {
+    if (group.length === 1) {
+      const only = group[0];
+      return { ...only, roots: only.roots.length > 0 ? only.roots : [only.root] };
+    }
+    const primary =
+      group.find((e) => e.bindings.some((b) => b.machine_id == null)) ?? group[0];
+    const roots = [...new Set(group.flatMap((e) => (e.roots.length > 0 ? e.roots : [e.root])))];
+    const kinds = group.map((e) => e.kind);
+    const kind = kinds.reduce((best, next) =>
+      ENTRY_KIND_RANK[next] < ENTRY_KIND_RANK[best] ? next : best,
+    );
+    return {
+      ...primary,
+      roots,
+      bindings: group.flatMap((e) => e.bindings),
+      isLive: group.some((e) => e.isLive),
+      kind,
+    };
+  });
+  return [...standalone, ...merged];
+}
+
 /**
  * Canonical binding for an entry — global (`machine_id IS NULL`) first,
  * else first machine-scoped binding.
@@ -278,13 +326,15 @@ export function WorkspacesPage() {
         id: '',
         kind: 'unmapped-live',
         root,
+        roots: [root],
         bindings: binds,
         isLive: true,
       });
       const entry: Entry = {
         id: primary?.id ?? `live:${root}`,
         kind: 'unmapped-live',
         root,
+        roots: [root],
         bindings: binds,
         isLive: true,
       };
@@ -305,13 +355,15 @@ export function WorkspacesPage() {
         id: '',
         kind: 'mapped-offline',
         root: b.workspace_root,
+        roots: [b.workspace_root],
         bindings: binds,
         isLive: false,
       });
       list.push({
         id: primary!.id,
         kind: 'mapped-offline',
         root: b.workspace_root,
+        roots: [b.workspace_root],
         bindings: binds,
         isLive: false,
       });
@@ -325,19 +377,14 @@ export function WorkspacesPage() {
         id: b.id,
         kind: 'mapped-offline',
         root: b.workspace_root,
+        roots: [b.workspace_root],
         bindings: [b],
         isLive: false,
         isClientMapping: true,
       });
     }
-    const rank: Record<EntryKind, number> = {
-      'unmapped-live': 0,
-      'live-elsewhere': 1,
-      'mapped-live': 2,
-      'mapped-offline': 3,
-    };
-    return list.sort((a, b) => {
-      const o = rank[a.kind] - rank[b.kind];
+    return mergeByProjectKey(list).sort((a, b) => {
+      const o = ENTRY_KIND_RANK[a.kind] - ENTRY_KIND_RANK[b.kind];
       return o !== 0 ? o : a.root.localeCompare(b.root);
     });
   }, [bindings, bindingsByRoot, reportedRoots, localMachineId, viewerMachineId]);
@@ -377,6 +424,7 @@ export function WorkspacesPage() {
       const label = binding?.label?.toLowerCase() ?? '';
       return (
         e.root.toLowerCase().includes(q) ||
+        e.roots.some((root) => root.toLowerCase().includes(q)) ||
         label.includes(q) ||
         spaceName.toLowerCase().includes(q) ||
         fsNames.toLowerCase().includes(q)
@@ -786,6 +834,8 @@ interface EntryCardRoutingRow {
   ghost?: boolean;
   machine?: Machine;
   machineLabel: string;
+  /** Shown under the machine when the card spans more than one path. */
+  root?: string;
   fsName: string;
   spaceName: string | undefined;
   clickable: boolean;
@@ -868,12 +918,19 @@ function EntryCardRoutingTable({
               ].join(' ')}
               {...rowProps}
             >
-              <span className={`${cellCls} truncate whitespace-nowrap`} title={row.machineLabel}>
-                <span className="inline-flex max-w-full items-center gap-1">
-                  {row.machine?.icon ? (
-                    <span className="shrink-0 text-[11px] leading-none">{row.machine.icon}</span>
+              <span className={`${cellCls} whitespace-nowrap`} title={row.root ?? row.machineLabel}>
+                <span className="inline-flex max-w-full flex-col">
+                  <span className="inline-flex max-w-full items-center gap-1">
+                    {row.machine?.icon ? (
+                      <span className="shrink-0 text-[11px] leading-none">{row.machine.icon}</span>
+                    ) : null}
+                    <span className="truncate">{row.machineLabel}</span>
+                  </span>
+                  {row.root ? (
+                    <span className="truncate font-mono text-[10px] text-[rgb(var(--muted))]">
+                      {row.root}
+                    </span>
                   ) : null}
-                  <span className="truncate">{row.machineLabel}</span>
                 </span>
               </span>
               <span
@@ -911,6 +968,7 @@ function buildEntryRoutingRows(
   fsById: Map<string, FeatureSet>,
   t: TFunction<['workspaces', 'common']>,
 ): EntryCardRoutingRow[] {
+  const showPath = entry.roots.length > 1;
   const rows: EntryCardRoutingRow[] = bindings.map((rowBinding) => {
     const rowMachine = rowBinding.machine_id
       ? machinesById.get(rowBinding.machine_id)
@@ -920,6 +978,7 @@ function buildEntryRoutingRows(
       bindingId: rowBinding.id,
       machine: rowMachine,
       machineLabel: machineBindingLabel(rowBinding, machinesById, t),
+      root: showPath ? rowBinding.workspace_root : undefined,
       fsName: formatFsList(
         rowBinding.feature_set_ids.map((id) => fsById.get(id)?.name ?? id),
       ),
@@ -1101,12 +1160,24 @@ function EntryCard({
             </p>
             <p
               className={`mt-0.5 line-clamp-2 min-h-[2rem] font-mono text-xs leading-snug text-[rgb(var(--muted))] ${
-                hasLabel || entry.isClientMapping ? 'break-all' : 'invisible'
+                hasLabel || entry.isClientMapping || entry.roots.length > 1
+                  ? 'break-all'
+                  : 'invisible'
               }`}
-              title={hasLabel || entry.isClientMapping ? entry.root : undefined}
-              aria-hidden={!hasLabel && !entry.isClientMapping}
+              title={
+                entry.roots.length > 1
+                  ? entry.roots.join(', ')
+                  : hasLabel || entry.isClientMapping
+                    ? entry.root
+                    : undefined
+              }
+              aria-hidden={!hasLabel && !entry.isClientMapping && entry.roots.length <= 1}
             >
-              {hasLabel || entry.isClientMapping ? entry.root : '\u00A0'}
+              {entry.roots.length > 1
+                ? t('card.locations', { count: entry.roots.length })
+                : hasLabel || entry.isClientMapping
+                  ? entry.root
+                  : '\u00A0'}
             </p>
             {entry.kind === 'unmapped-live' && (
               <Button

apps/desktop/src/features/workspaces/workspace-binding-form.helpers.ts

@@ -45,6 +45,26 @@ export function folderName(root: string): string {
  * Bindings on other machines (or scopes) that can seed a new create-from-live row.
  * Same folder name is enough; identical absolute paths count when machine differs.
  */
+/**
+ * Grouping key for cross-machine project cards. Manual link wins over git remote.
+ */
+export function projectKey(binding: WorkspaceBinding): string | null {
+  return binding.project_link_id || binding.git_remote_url || null;
+}
+
+/**
+ * Path-type bindings the user can manually link to, excluding `excludeId`.
+ */
+export function findLinkableBindings(
+  allBindings: WorkspaceBinding[],
+  excludeId: string | undefined,
+): WorkspaceBinding[] {
+  return allBindings.filter((binding) => {
+    if (binding.id === excludeId) return false;
+    return binding.binding_type !== 'id';
+  });
+}
+
 export function findAdoptableSiblingBindings(
   allBindings: WorkspaceBinding[],
   workspaceRoot: string,