fix: add workspace routing to cloud upload and API client

Cloud upload, project existence checks, and project creation now
resolve and pass the X-Workspace-ID header for teams workspace
support. The get_client() per-project routing also auto-resolves
workspace from project config when not explicitly provided.

Fixes #703

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Drew Cain <groksrc@gmail.com>

Author: groksrc

src/basic_memory/cli/commands/cloud/cloud_utils.py

@@ -16,8 +16,16 @@ class CloudUtilsError(Exception):
     pass
 
 
+def _workspace_headers(workspace: str | None = None) -> dict[str, str]:
+    """Build workspace header if workspace is specified."""
+    if workspace:
+        return {"X-Workspace-ID": workspace}
+    return {}
+
+
 async def fetch_cloud_projects(
     *,
+    workspace: str | None = None,
     api_request=make_api_request,
 ) -> CloudProjectList:
     """Fetch list of projects from cloud API.
@@ -30,7 +38,11 @@ async def fetch_cloud_projects(
         config = config_manager.config
         host_url = config.cloud_host.rstrip("/")
 
-        response = await api_request(method="GET", url=f"{host_url}/proxy/v2/projects/")
+        response = await api_request(
+            method="GET",
+            url=f"{host_url}/proxy/v2/projects/",
+            headers=_workspace_headers(workspace),
+        )
 
         return CloudProjectList.model_validate(response.json())
     except Exception as e:
@@ -40,12 +52,14 @@ async def fetch_cloud_projects(
 async def create_cloud_project(
     project_name: str,
     *,
+    workspace: str | None = None,
     api_request=make_api_request,
 ) -> CloudProjectCreateResponse:
     """Create a new project on cloud.
 
     Args:
         project_name: Name of project to create
+        workspace: Cloud workspace tenant_id to create project in
 
     Returns:
         CloudProjectCreateResponse with project details from API
@@ -64,10 +78,13 @@ async def create_cloud_project(
             set_default=False,
         )
 
+        headers = {"Content-Type": "application/json"}
+        headers.update(_workspace_headers(workspace))
+
         response = await api_request(
             method="POST",
             url=f"{host_url}/proxy/v2/projects/",
-            headers={"Content-Type": "application/json"},
+            headers=headers,
             json_data=project_data.model_dump(),
         )
 
@@ -91,17 +108,23 @@ async def sync_project(project_name: str, force_full: bool = False) -> None:
         raise CloudUtilsError(f"Failed to sync project '{project_name}': {e}") from e
 
 
-async def project_exists(project_name: str, *, api_request=make_api_request) -> bool:
+async def project_exists(
+    project_name: str,
+    *,
+    workspace: str | None = None,
+    api_request=make_api_request,
+) -> bool:
     """Check if a project exists on cloud.
 
     Args:
         project_name: Name of project to check
+        workspace: Cloud workspace tenant_id to check in
 
     Returns:
         True if project exists, False otherwise
     """
     try:
-        projects = await fetch_cloud_projects(api_request=api_request)
+        projects = await fetch_cloud_projects(workspace=workspace, api_request=api_request)
         project_names = {p.name for p in projects.projects}
         return project_name in project_names
     except Exception:

src/basic_memory/cli/commands/cloud/upload_command.py

@@ -13,6 +13,7 @@
     sync_project,
 )
 from basic_memory.cli.commands.cloud.upload import upload_path
+from basic_memory.config import ConfigManager
 from basic_memory.mcp.async_client import get_cloud_control_plane_client
 
 console = Console()
@@ -73,12 +74,21 @@ def upload(
     """
 
     async def _upload():
+        # Resolve workspace: per-project workspace_id, then default_workspace
+        config = ConfigManager().config
+        workspace = None
+        entry = config.projects.get(project)
+        if entry and entry.workspace_id:
+            workspace = entry.workspace_id
+        elif config.default_workspace:
+            workspace = config.default_workspace
+
         # Check if project exists
-        if not await project_exists(project):
+        if not await project_exists(project, workspace=workspace):
             if create_project:
                 console.print(f"[blue]Creating cloud project '{project}'...[/blue]")
                 try:
-                    await create_cloud_project(project)
+                    await create_cloud_project(project, workspace=workspace)
                     console.print(f"[green]Created project '{project}'[/green]")
                 except Exception as e:
                     console.print(f"[red]Failed to create project: {e}[/red]")
@@ -93,20 +103,25 @@ async def _upload():
                 raise typer.Exit(1)
 
         # Perform upload (or dry run)
+        if workspace:
+            console.print(f"[dim]Using workspace: {workspace}[/dim]")
         if dry_run:
             console.print(
                 f"[yellow]DRY RUN: Showing what would be uploaded to '{project}'[/yellow]"
             )
         else:
             console.print(f"[blue]Uploading {path} to project '{project}'...[/blue]")
 
+        def _client_factory():
+            return get_cloud_control_plane_client(workspace=workspace)
+
         success = await upload_path(
             path,
             project,
             verbose=verbose,
             use_gitignore=not no_gitignore,
             dry_run=dry_run,
-            client_cm_factory=get_cloud_control_plane_client,
+            client_cm_factory=_client_factory,
         )
         if not success:
             console.print("[red]Upload failed[/red]")

src/basic_memory/mcp/async_client.py

@@ -88,15 +88,20 @@ async def _cloud_client(
 
 
 @asynccontextmanager
-async def get_cloud_control_plane_client() -> AsyncIterator[AsyncClient]:
+async def get_cloud_control_plane_client(
+    workspace: Optional[str] = None,
+) -> AsyncIterator[AsyncClient]:
     """Create a control-plane cloud client for endpoints outside /proxy."""
     config = ConfigManager().config
     timeout = _build_timeout()
     token = await _resolve_cloud_token(config)
+    headers: dict[str, str] = {"Authorization": f"Bearer {token}"}
+    if workspace:
+        headers["X-Workspace-ID"] = workspace
     logger.info(f"Creating HTTP client for cloud control plane at: {config.cloud_host}")
     async with AsyncClient(
         base_url=config.cloud_host,
-        headers={"Authorization": f"Bearer {token}"},
+        headers=headers,
         timeout=timeout,
     ) as client:
         yield client
@@ -179,8 +184,16 @@ async def get_client(
         project_mode = config.get_project_mode(project_name)
         if project_mode == ProjectMode.CLOUD:
             logger.debug(f"Project '{project_name}' is cloud mode - using cloud proxy client")
+            # Resolve workspace from project config if not explicitly provided
+            effective_workspace = workspace
+            if effective_workspace is None:
+                entry = config.projects.get(project_name)
+                if entry and entry.workspace_id:
+                    effective_workspace = entry.workspace_id
+                elif config.default_workspace:
+                    effective_workspace = config.default_workspace
             try:
-                async with _cloud_client(config, timeout, workspace=workspace) as client:
+                async with _cloud_client(config, timeout, workspace=effective_workspace) as client:
                     yield client
             except RuntimeError as exc:
                 raise RuntimeError(