Migrate dump_config_cmd to external API server. Improve error handling in api client

Author: Aksem

docs/api-protocol.md

@@ -193,6 +193,40 @@ from context.
 
 ---
 
+#### `workspace/getProjectRawConfig`
+
+Return the fully resolved raw configuration for a project, as stored in the
+workspace context after config reading and preset resolution.
+
+- **Type:** request
+- **Clients:** CLI
+- **Status:** implemented
+
+**Params:**
+
+```json
+{"project": "my_project"}
+```
+
+**Result:**
+
+```json
+{
+  "raw_config": {
+    "tool": { "finecode": { ... } },
+    ...
+  }
+}
+```
+
+**Errors:**
+
+- `project` is required — returns a JSON-RPC error if omitted.
+- Project not found — returns a JSON-RPC error if no project with the given name
+  exists in the workspace context.
+
+---
+
 ### `actions/` — Action Discovery & Execution
 
 #### `actions/list`

src/finecode/api_client.py

@@ -19,6 +19,26 @@
 CONTENT_LENGTH_HEADER = "Content-Length: "
 
 
+class ApiError(Exception):
+    """Base class for API client errors."""
+
+
+class ApiServerError(ApiError):
+    """Server returned a JSON-RPC error response."""
+
+    def __init__(self, code: int, message: str) -> None:
+        self.code = code
+        super().__init__(f"API error ({code}): {message}")
+
+
+class ApiResponseError(ApiError):
+    """Server returned an unexpected or malformed response."""
+
+    def __init__(self, method: str, detail: str) -> None:
+        self.method = method
+        super().__init__(f"Unexpected response for '{method}': {detail}")
+
+
 async def _read_message(reader: asyncio.StreamReader) -> dict | None:
     """Read one Content-Length framed JSON-RPC message. Returns None on EOF."""
     header_line = await reader.readline()
@@ -43,6 +63,11 @@ class ApiClient:
     After connect(), a background reader loop dispatches incoming messages:
     - Responses (with ``id``) resolve the matching pending request future.
     - Notifications (without ``id``) are dispatched to registered callbacks.
+
+    Errors:
+    - ``ApiServerError``: the server returned a JSON-RPC error.
+    - ``ApiResponseError``: the server response was missing an expected field.
+    - ``ConnectionError``: the connection was lost.
     """
 
     def __init__(self) -> None:
@@ -110,14 +135,34 @@ async def find_project_for_file(self, file_path: str) -> str | None:
             "workspace/findProjectForFile", {"file_path": file_path}
         )
         # server returns {"project": name | None}
+        if not isinstance(result, dict):
+            raise ApiResponseError(
+                "workspace/findProjectForFile", f"expected dict, got {type(result).__name__}"
+            )
         return result.get("project")
 
+    async def get_project_raw_config(self, project: str) -> dict:
+        """Return the resolved raw config for a project by name."""
+        result = await self.request(
+            "workspace/getProjectRawConfig", {"project": project}
+        )
+        if not isinstance(result, dict) or "raw_config" not in result:
+            raise ApiResponseError(
+                "workspace/getProjectRawConfig",
+                f"missing 'raw_config' field, got {result!r}",
+            )
+        return result["raw_config"]
+
     async def list_actions(self, project: str | None = None) -> list[dict]:
         """List available actions, optionally filtered by project name."""
         params: dict = {}
         if project is not None:
             params["project"] = project
         result = await self.request("actions/list", params)
+        if not isinstance(result, dict) or "actions" not in result:
+            raise ApiResponseError(
+                "actions/list", f"missing 'actions' field, got {result!r}"
+            )
         return result["actions"]
 
     async def get_tree(self, parent_node_id: str | None = None) -> dict:
@@ -248,7 +293,12 @@ def _send_notification(self, method: str, params: dict | None = None) -> None:
     # -- Low-level request --------------------------------------------------
 
     async def request(self, method: str, params: dict | None = None) -> dict:
-        """Send a JSON-RPC request and wait for the response."""
+        """Send a JSON-RPC request and wait for the response.
+
+        Raises:
+            ApiServerError: the server returned a JSON-RPC error.
+            ConnectionError: the connection was closed before a response arrived.
+        """
         if self._writer is None:
             raise RuntimeError("Not connected to FineCode API server")
 
@@ -273,7 +323,7 @@ async def request(self, method: str, params: dict | None = None) -> dict:
 
         if "error" in response:
             error = response["error"]
-            raise RuntimeError(f"API error ({error['code']}): {error['message']}")
+            raise ApiServerError(error["code"], error["message"])
 
         return response.get("result")
 

src/finecode/api_server/api_server.py

@@ -181,6 +181,27 @@ async def _handle_list_projects(
     return [_project_to_dict(p) for p in ws_context.ws_projects.values()]
 
 
+async def _handle_get_project_raw_config(
+    params: dict | None, ws_context: context.WorkspaceContext
+) -> dict:
+    """Return the resolved raw config for a project by name.
+
+    Params: ``{"project": "project_name"}``
+    Result: ``{"raw_config": {...}}``
+    """
+    params = params or {}
+    project_name = params.get("project")
+    if not project_name:
+        raise ValueError("project parameter is required")
+
+    for project_dir_path, project in ws_context.ws_projects.items():
+        if project.name == project_name:
+            raw_config = ws_context.ws_projects_raw_configs.get(project_dir_path, {})
+            return _NoConvert({"raw_config": raw_config})
+
+    raise ValueError(f"Project '{project_name}' not found")
+
+
 async def _handle_find_project_for_file(
     params: dict, ws_context: context.WorkspaceContext
 ) -> dict:
@@ -792,6 +813,7 @@ async def _handle_run_with_partial_results_task(
     "workspace/addDir": _handle_add_dir,
     "workspace/removeDir": _handle_remove_dir,
     "workspace/setConfigOverrides": _handle_set_config_overrides,
+    "workspace/getProjectRawConfig": _handle_get_project_raw_config,
     # actions/
     "actions/list": _handle_list_actions,
     "actions/getTree": _handle_get_tree,

src/finecode/cli.py

@@ -423,7 +423,8 @@ def prepare_envs(trace: bool, debug: bool, recreate: bool) -> None:
 @click.option("--trace", "trace", is_flag=True, default=False)
 @click.option("--debug", "debug", is_flag=True, default=False)
 @click.option("--project", "project", type=str)
-def dump_config(trace: bool, debug: bool, project: str | None):
+@click.option("--shared-server", "shared_server", is_flag=True, default=False)
+def dump_config(trace: bool, debug: bool, project: str | None, shared_server: bool):
     if debug is True:
         import debugpy
 
@@ -443,7 +444,9 @@ def dump_config(trace: bool, debug: bool, project: str | None):
     try:
         asyncio.run(
             dump_config_cmd.dump_config(
-                workdir_path=pathlib.Path(os.getcwd()), project_name=project
+                workdir_path=pathlib.Path(os.getcwd()),
+                project_name=project,
+                own_server=not shared_server,
             )
         )
     except dump_config_cmd.DumpFailed as exception:

src/finecode/cli_app/commands/dump_config_cmd.py

@@ -1,91 +1,67 @@
 import pathlib
 
-from loguru import logger
-
-from finecode.api_server import context
-from finecode.api_server.services import run_service, shutdown_service
-from finecode.api_server.config import config_models, read_configs
-from finecode.api_server.runner import runner_manager
+from finecode.api_client import ApiClient, ApiError
+from finecode.api_server import api_server
 
 
 class DumpFailed(Exception):
     def __init__(self, message: str) -> None:
         self.message = message
 
 
-async def dump_config(workdir_path: pathlib.Path, project_name: str):
-    ws_context = context.WorkspaceContext([workdir_path])
-    # it could be optimized by looking for concrete project instead of all
-    await read_configs.read_projects_in_dir(
-        dir_path=workdir_path, ws_context=ws_context
-    )
-
-    # project is provided. Filter out other projects if there are more, they would
-    # not be used (run can be started in a workspace with also other projects)
-    ws_context.ws_projects = {
-        project_dir_path: project
-        for project_dir_path, project in ws_context.ws_projects.items()
-        if project.name == project_name
-    }
-
-    # read configs without presets, this is required to be able to start runners in
-    # the next step
-    for project in ws_context.ws_projects.values():
-        try:
-            await read_configs.read_project_config(
-                project=project, ws_context=ws_context, resolve_presets=False
-            )
-        except config_models.ConfigurationError as exception:
-            raise DumpFailed(
-                f"Reading project configs(without presets) in {project.dir_path} failed: {exception.message}"
-            ) from exception
-
-    # Some tools like IDE extensions for syntax highlighting rely on
-    # file name. Keep file name of config the same and save in subdirectory
-    project_dir_path = list(ws_context.ws_projects.keys())[0]
-    dump_dir_path = project_dir_path / "finecode_config_dump"
-    dump_file_path = dump_dir_path / "pyproject.toml"
-    project_def = ws_context.ws_projects[project_dir_path]
-    actions_by_projects = {project_dir_path: ["dump_config"]}
-
-    # start runner to init project config
+async def dump_config(
+    workdir_path: pathlib.Path, project_name: str, own_server: bool = True
+):
+    port_file = None
     try:
-        # reread projects configs, now with resolved presets
-        # to be able to resolve presets, start runners with presets first
-        try:
-            await runner_manager.start_runners_with_presets(
-                projects=[project_def], ws_context=ws_context
-            )
-        except runner_manager.RunnerFailedToStart as exception:
-            raise DumpFailed(
-                f"Starting runners with presets failed: {exception.message}"
-            ) from exception
+        if own_server:
+            port_file = api_server.start_own_server(workdir_path)
+            try:
+                port = await api_server.wait_until_ready_from_file(port_file)
+            except TimeoutError as exc:
+                raise DumpFailed(str(exc)) from exc
+        else:
+            api_server.ensure_running(workdir_path)
+            try:
+                port = await api_server.wait_until_ready()
+            except TimeoutError as exc:
+                raise DumpFailed(str(exc)) from exc
 
+        client = ApiClient()
+        await client.connect("127.0.0.1", port)
         try:
-            await run_service.start_required_environments(
-                actions_by_projects, ws_context
+            result = await client.add_dir(workdir_path)
+            projects = result.get("projects", [])
+            project = next(
+                (p for p in projects if p["name"] == project_name), None
             )
-        except run_service.StartingEnvironmentsFailed as exception:
-            raise DumpFailed(
-                f"Failed to start environments for running 'dump_config': {exception.message}"
-            ) from exception
+            if project is None:
+                raise DumpFailed(f"Project '{project_name}' not found")
 
-        project_raw_config = ws_context.ws_projects_raw_configs[project_dir_path]
+            project_dir_path = pathlib.Path(project["path"])
+            source_file_path = project_dir_path / "pyproject.toml"
+            target_file_path = project_dir_path / "finecode_config_dump" / "pyproject.toml"
 
-        await run_service.run_action(
-            action_name="dump_config",
-            params={
-                "source_file_path": project_def.def_path,
-                "project_raw_config": project_raw_config,
-                "target_file_path": dump_file_path,
-            },
-            project_def=project_def,
-            ws_context=ws_context,
-            result_formats=[run_service.RunResultFormat.STRING],
-            preprocess_payload=False,
-            run_trigger=run_service.RunActionTrigger.USER,
-            dev_env=run_service.DevEnv.CLI,
-        )
-        logger.info(f"Dumped config into {dump_file_path}")
+            try:
+                project_raw_config = await client.get_project_raw_config(project_name)
+                await client.run_action(
+                    action="dump_config",
+                    project=project_name,
+                    params={
+                        "source_file_path": str(source_file_path),
+                        "project_raw_config": project_raw_config,
+                        "target_file_path": str(target_file_path),
+                    },
+                    options={
+                        "result_formats": ["string"],
+                        "trigger": "user",
+                        "dev_env": "cli",
+                    },
+                )
+            except ApiError as exc:
+                raise DumpFailed(str(exc)) from exc
+        finally:
+            await client.close()
     finally:
-        shutdown_service.on_shutdown(ws_context)
+        if port_file is not None and port_file.exists():
+            port_file.unlink(missing_ok=True)

src/finecode/cli_app/commands/run_cmd.py

@@ -5,7 +5,7 @@
 
 import click
 
-from finecode.api_client import ApiClient
+from finecode.api_client import ApiClient, ApiError
 from finecode.api_server import api_server
 from finecode.api_server.runner import runner_client
 from finecode.cli_app import utils
@@ -53,7 +53,8 @@ async def run_actions(
                         "Warning: --config overrides are ignored in --shared-server mode. ",
                         err=True,
                     )
-
+            # TODO: could it be optimized: if projects are provided, parse only them?
+            # the same also in other CLI commands
             await client.add_dir(workdir_path)
 
             params_by_project: dict[str, dict[str, typing.Any]] = {}
@@ -78,7 +79,7 @@ async def run_actions(
                         "dev_env": "cli",
                     },
                 )
-            except RuntimeError as exc:
+            except ApiError as exc:
                 raise RunFailed(str(exc)) from exc
 
             return _build_run_result(batch_result)