synapse-cli-agent 0.1.51__tar.gz → 0.1.53__tar.gz

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/CHANGELOG.md

@@ -6,6 +6,43 @@ Each release section starts with `## v{version}` and ends before the next `## `
 The release workflow automatically extracts the matching section as release notes.
 All entries are written in English.
 
+## v0.1.53
+
+### New Features
+
+- **Workspace Resume**: Restore the last selected project in the desktop console when it remains available to the runtime.
+
+### Bug Fixes
+
+- **Desktop Startup Workspace**: Prevent the packaged sidecar's `binaries` directory, including previously registered installations, from becoming the default project.
+- **Codex Usage Refresh**: Read usage and reset credits concurrently while keeping credit redemption exclusive and idempotent.
+
+### Engineering
+
+- **Safe Codex Diagnostics**: Persist bounded daemon-side error categories and HTTP status codes in a rotating private log without exposing upstream response text or credentials to the console.
+- Added regression tests for workspace fallback, Codex read concurrency, and redacted error logs.
+
+---
+
+## v0.1.52
+
+### New Features
+
+- **Model Maintenance Section in Settings**: Added comprehensive model endpoint CRUD interface in the Web Console settings surface with provider grouping, proxy/WebSocket/streaming visibility, and diff-merge overwrite protection.
+- **MCP Maintenance Section in Settings**: Added dedicated MCP maintenance tab with granular per-server start/stop toggling, individual tool method whitelist selection/filtering, and full CRUD operations (add, edit, delete, reconnect).
+
+### Bug Fixes
+
+- **Accurate MCP Status Transition Text**: Resolved misleading transition state text by displaying "停止中…" instead of "启动中…" when stopping an MCP server, and strictly isolated per-server state transitions from unaffected servers.
+- **Incremental MCP Session Pool Reuse**: Ensured healthy existing connections are preserved and reused during MCP session rebinding without causing mass reconnections.
+- **Safe MCP Server Fallback**: Guarded list and management RPC endpoints against inactive sessions so the maintenance UI remains functional before any chat thread is opened.
+
+### Engineering
+
+- Added comprehensive unit tests and TypeScript contract guards covering MCP and Model maintenance RPCs (`runtime.mcp.*`, `runtime.models.*`).
+
+---
+
 ## v0.1.51
 
 ### New Features

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.51
+Version: 0.1.53
 Summary: Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)
 Project-URL: Homepage, https://github.com/alex8224/synapse-agent
 Project-URL: Repository, https://github.com/alex8224/synapse-agent

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.51"
+version = "0.1.53"
 description = "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)"
 readme = "README.md"
 license = { file = "LICENSE" }

synapse_cli_agent-0.1.53/release_body.md

@@ -0,0 +1,17 @@
+## v0.1.53
+
+### New Features
+
+- **Workspace Resume**: Restore the last selected project in the desktop console when it remains available to the runtime.
+
+### Bug Fixes
+
+- **Desktop Startup Workspace**: Prevent the packaged sidecar's `binaries` directory, including previously registered installations, from becoming the default project.
+- **Codex Usage Refresh**: Read usage and reset credits concurrently while keeping credit redemption exclusive and idempotent.
+
+### Engineering
+
+- **Safe Codex Diagnostics**: Persist bounded daemon-side error categories and HTTP status codes in a rotating private log without exposing upstream response text or credentials to the console.
+- Added regression tests for workspace fallback, Codex read concurrency, and redacted error logs.
+
+---

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/integrations/mcp_client.py

@@ -707,6 +707,34 @@ class McpSessionPool:
 
     async def _open_one(self, server: McpServerConfig) -> tuple[_LiveServer | None, str | None]:
         if not server.enabled:
+            old = self._servers.pop(server.name, None)
+            if old is not None:
+                try:
+                    await old.session_cm.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                try:
+                    await old.transport_cm.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                if old.errlog is not None:
+                    old.errlog.close()
+            return None, None
+
+        existing = self._servers.get(server.name)
+        if (
+            existing is not None
+            and getattr(existing, "session", None) is not None
+            and existing.config.transport == server.transport
+            and existing.config.command == server.command
+            and existing.config.args == server.args
+            and existing.config.env == server.env
+            and existing.config.url == server.url
+            and existing.config.headers == server.headers
+        ):
+            existing.config = server
+            return existing, None
+
             return None, None
         timeout_sec = server.timeout if server.timeout > 0 else 12.0
         try:
@@ -857,6 +885,22 @@ class McpSessionPool:
             *[_load_one(s) for s in servers], return_exceptions=True
         )
 
+        configured_names = {s.name for s in servers}
+        for name in list(self._servers.keys()):
+            if name not in configured_names:
+                old = self._servers.pop(name, None)
+                if old is not None:
+                    try:
+                        await old.session_cm.__aexit__(None, None, None)
+                    except Exception:
+                        pass
+                    try:
+                        await old.transport_cm.__aexit__(None, None, None)
+                    except Exception:
+                        pass
+                    if old.errlog is not None:
+                        old.errlog.close()
+
         tools: list[Any] = []
         warnings: list[str] = []
         ok_servers: list[str] = []

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/models/persist.py

@@ -29,7 +29,7 @@ from synapse.models.registry import _profiles_from_mapping, resolve_models_confi
 from synapse.settings.config_paths import MODELS_FILENAME, project_config_dir
 
 # Alias appears in /model reload commands; keep it a single safe token.
-_VALID_ALIAS = re.compile(r"^[A-Za-z0-9_.:-]+$")
+_VALID_ALIAS = re.compile(r"^[\w.:\-\u4e00-\u9fa5]+$")
 
 
 class ModelsStoreError(ValueError):
@@ -43,6 +43,7 @@ _PROFILE_FIELDS = (
     "api_key_env",
     "auth",
     "base_url",
+    "provider",
     "headers",
     "context_window",
     "enable_thinking",
@@ -54,6 +55,8 @@ _PROFILE_FIELDS = (
     "extra",
     "model_kwargs",
     "extra_body",
+    "openai_proxy",
+    "streaming",
 )
 
 

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/models/registry.py

@@ -158,6 +158,9 @@ class ModelRegistry:
     def list_names(self) -> list[str]:
         return sorted(self.profiles)
 
+    def list_profiles(self) -> list[ModelProfile]:
+        return list(self.profiles.values())
+
     def get(self, name: str | None = None) -> ModelProfile:
         key = (name or self.default or "").strip()
         if not key:
@@ -224,6 +227,8 @@ class ModelRegistry:
         profile = self.get(name)
         kwargs: dict[str, Any] = dict(profile.extra or {})
         model_name = profile.model
+        if ":" not in model_name and profile.provider:
+            model_name = f"{profile.provider}:{model_name}"
         configured_headers = _merge_headers(self.headers, profile.headers)
 
         api_key = profile.resolved_api_key() or fallback_api_key
@@ -965,7 +970,7 @@ def registry_from_settings(settings: Any) -> ModelRegistry:
     if reg is not None:
         selected = (getattr(settings, "active_model", None) or "").strip()
         if not selected:
-            candidate = (settings.model or "").strip()
+            candidate = (getattr(settings, "model", None) or "").strip()
             if candidate in reg.profiles:
                 selected = candidate
         if selected:

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/runtime/daemon/application.py

@@ -160,26 +160,29 @@ def apply_mcp_rebinding(
                 workspace=descriptor.workspace,
                 explicit_path=project_settings.mcp_config_path,
             )
-        registry.release(pool_key)
     settings = load_project_settings(descriptor.workspace)
     active_model = binding.settings.active_model or binding.settings.model
     profile = registry_from_settings(settings).get(active_model)
     apply_profile_to_settings(settings, profile, seed_thinking=False)
+    from synapse.integrations.mcp_client import load_mcp_server_configs
+
+    server_configs = load_mcp_server_configs(
+        path=settings.mcp_config_path,
+        json_blob=settings.mcp_servers_json,
+        workspace=descriptor.workspace,
+    )
     live = registry.get(pool_key)
-    if live is not None and live.tools:
+    if live is not None:
+        load_result = live.load(server_configs)
         agent = build_coding_agent(
             settings,
             project_root=descriptor.workspace,
-            mcp_tools=list(live.tools),
+            mcp_tools=list(load_result.tools),
             load_mcp=False,
             prompt_cache_key=lambda: thread_id,
             mcp_pool_key=pool_key,
         )
     else:
-        if live is not None:
-            # An empty pool would be reused by key: drop it so the rebuild
-            # reconnects instead of attaching nothing.
-            registry.release(pool_key)
         agent = build_coding_agent(
             settings,
             project_root=descriptor.workspace,

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/runtime/daemon/codex_usage.py

@@ -156,11 +156,11 @@ class CodexUsageAdapter:
     """Real :class:`CodexUsageProvider` implementation for the daemon."""
 
     def __init__(self) -> None:
-        # One lock serializes every client call (reads and the consume write):
-        # the endpoints are account-scoped, so interleaving them could serve a
-        # snapshot that predates a redemption.  All ledger state is mutated
-        # under this lock, on the worker thread, never on the event loop.
+        # Writes remain exclusive, while independent GETs may run together.
+        # A writer waits for in-flight reads before checking/redeeming a credit.
         self._lock = threading.RLock()
+        self._reads_done = threading.Condition(self._lock)
+        self._active_reads = 0
         self._client: CodexUsageClient | None = None
         #: command_id -> (fingerprint, settled result); bounded replay ledger.
         self._commands: OrderedDict[str, tuple[tuple[str, ...], CodexConsumeResult]] = OrderedDict()
@@ -217,11 +217,25 @@ class CodexUsageAdapter:
 
     def _fetch_usage(self, force: bool) -> CodexUsageSnapshot:
         with self._lock:
-            return self._codex_client().fetch(force=force)
+            client = self._codex_client()
+            self._active_reads += 1
+        try:
+            return client.fetch(force=force)
+        finally:
+            with self._lock:
+                self._active_reads -= 1
+                self._reads_done.notify_all()
 
     def _fetch_credits(self, force: bool) -> ResetCredits:
         with self._lock:
-            return self._codex_client().fetch_reset_credits(force=force)
+            client = self._codex_client()
+            self._active_reads += 1
+        try:
+            return client.fetch_reset_credits(force=force)
+        finally:
+            with self._lock:
+                self._active_reads -= 1
+                self._reads_done.notify_all()
 
     # -- consume / idempotency ---------------------------------------------
 
@@ -229,6 +243,8 @@ class CodexUsageAdapter:
         self, command: ConsumeCodexResetCommand, model: str
     ) -> CodexConsumeResult:
         with self._lock:
+            while self._active_reads:
+                self._reads_done.wait()
             client = self._codex_client()
             account = client.account_key() or "unknown-account"
             fingerprint = (

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/runtime/daemon/entry.py

@@ -4,11 +4,33 @@ from __future__ import annotations
 
 import argparse
 import asyncio
+import logging
+import os
 import sys
+from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
 from synapse.runtime.daemon.application import run_daemon
-from synapse.runtime.daemon.config import DaemonConfig
+from synapse.runtime.daemon.config import DaemonConfig, ensure_directory
+
+
+def _configure_error_log(state_dir: Path) -> RotatingFileHandler:
+    """Persist bounded daemon errors even when launched without a console."""
+    ensure_directory(state_dir)
+    log_path = state_dir / "errors.log"
+    if log_path.is_symlink():
+        raise ValueError("daemon error log must not be a symlink")
+    handler = RotatingFileHandler(
+        log_path, maxBytes=1_000_000, backupCount=2, encoding="utf-8"
+    )
+    if os.name != "nt":
+        log_path.chmod(0o600)
+    handler.setLevel(logging.ERROR)
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s"))
+    logger = logging.getLogger("synapse.runtime.codex_usage")
+    logger.addHandler(handler)
+    logger.propagate = False
+    return handler
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -21,6 +43,7 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def main(argv: list[str] | None = None) -> int:
+    handler: RotatingFileHandler | None = None
     try:
         args = build_parser().parse_args(argv)
         config = DaemonConfig(
@@ -29,6 +52,7 @@ def main(argv: list[str] | None = None) -> int:
             state_dir=args.state_dir or DaemonConfig().state_dir,
             token_file=args.token_file,
         )
+        handler = _configure_error_log(config.state_dir)
         asyncio.run(run_daemon(config, stdout=sys.stdout))
         return 0
     except asyncio.CancelledError:
@@ -39,6 +63,10 @@ def main(argv: list[str] | None = None) -> int:
         return 2
     except KeyboardInterrupt:
         return 0
+    finally:
+        if handler is not None:
+            logging.getLogger("synapse.runtime.codex_usage").removeHandler(handler)
+            handler.close()
 
 
 if __name__ == "__main__":

{synapse_cli_agent-0.1.51 → synapse_cli_agent-0.1.53}/src/synapse/runtime/service/access.py

@@ -101,6 +101,21 @@ from synapse.runtime.service.history import (
     SessionHistoryPage,
     SessionListPage,
 )
+from synapse.runtime.service.mcp_management import (
+    DeleteMcpServerCommand,
+    ListMcpServersQuery,
+    McpServerListResult,
+    SaveMcpServerCommand,
+)
+from synapse.runtime.service.model_management import (
+    DeleteModelCommand,
+    ListModelsQuery,
+    ModelListResult,
+    SaveModelCommand,
+    SetDefaultModelCommand,
+    TestModelCommand,
+    TestModelResult,
+)
 from synapse.runtime.service.ports import AgentRuntimeService, EventWatch
 from synapse.runtime.service.project_list import (
     ListProjectsQuery,
@@ -184,6 +199,10 @@ __all__ = [
     "APPS_LIST",
     "SCREENSHOT_READ",
     "SCREENSHOT_CONTROL",
+    "MODELS_READ",
+    "MODELS_WRITE",
+    "MCP_READ",
+    "MCP_WRITE",
     "STT_CONTROL",
     "WORKSPACE_REVERT",
     "WORKSPACE_OPEN_EXTERNAL",
@@ -309,6 +328,10 @@ SCREENSHOT_CONTROL = "screenshot.control"
 #: its own grant -- ``session.read`` and ``attachments.write`` must never
 #: authorize it.
 STT_CONTROL = "stt.control"
+MODELS_READ = "models.read"
+MODELS_WRITE = "models.write"
+MCP_READ = "mcp.read"
+MCP_WRITE = "mcp.write"
 
 ALL_RUNTIME_CAPABILITIES = frozenset(
     {
@@ -351,6 +374,10 @@ ALL_RUNTIME_CAPABILITIES = frozenset(
         SCREENSHOT_READ,
         SCREENSHOT_CONTROL,
         STT_CONTROL,
+        MODELS_READ,
+        MODELS_WRITE,
+        MCP_READ,
+        MCP_WRITE,
     }
 )
 
@@ -1568,6 +1595,78 @@ class AccessControlledAgentRuntimeService:
             raise InvalidRequestError("session recovery is unavailable")
         return await delegate(query)
 
+    async def list_models(self, query: ListModelsQuery) -> ModelListResult:
+        session = self._session_from_dto(query, ListModelsQuery, "list models query")
+        self._authorize(session, MODELS_READ)
+        delegate = getattr(self._delegate, "list_models", None)
+        if not callable(delegate):
+            raise InvalidRequestError("model management is unavailable")
+        return await delegate(query)
+
+    async def save_model(self, command: SaveModelCommand) -> ModelListResult:
+        session = self._session_from_dto(command, SaveModelCommand, "save model command")
+        self._authorize(session, MODELS_WRITE)
+        delegate = getattr(self._delegate, "save_model", None)
+        if not callable(delegate):
+            raise InvalidRequestError("model management is unavailable")
+        return await delegate(command)
+
+    async def delete_model(self, command: DeleteModelCommand) -> ModelListResult:
+        session = self._session_from_dto(command, DeleteModelCommand, "delete model command")
+        self._authorize(session, MODELS_WRITE)
+        delegate = getattr(self._delegate, "delete_model", None)
+        if not callable(delegate):
+            raise InvalidRequestError("model management is unavailable")
+        return await delegate(command)
+
+    async def set_default_model(self, command: SetDefaultModelCommand) -> ModelListResult:
+        session = self._session_from_dto(
+            command, SetDefaultModelCommand, "set default model command"
+        )
+        self._authorize(session, MODELS_WRITE)
+        delegate = getattr(self._delegate, "set_default_model", None)
+        if not callable(delegate):
+            raise InvalidRequestError("model management is unavailable")
+        return await delegate(command)
+
+    async def test_model(self, command: TestModelCommand) -> TestModelResult:
+        session = self._session_from_dto(command, TestModelCommand, "test model command")
+        self._authorize(session, MODELS_READ)
+        delegate = getattr(self._delegate, "test_model", None)
+        if not callable(delegate):
+            raise InvalidRequestError("model management is unavailable")
+        return await delegate(command)
+
+    async def list_mcp_servers(self, query: ListMcpServersQuery) -> McpServerListResult:
+        session = self._session_from_dto(
+            query, ListMcpServersQuery, "list MCP servers query"
+        )
+        self._authorize(session, MCP_READ)
+        delegate = getattr(self._delegate, "list_mcp_servers", None)
+        if not callable(delegate):
+            raise InvalidRequestError("MCP management is unavailable")
+        return await delegate(query)
+
+    async def save_mcp_server(self, command: SaveMcpServerCommand) -> McpServerListResult:
+        session = self._session_from_dto(
+            command, SaveMcpServerCommand, "save MCP server command"
+        )
+        self._authorize(session, MCP_WRITE)
+        delegate = getattr(self._delegate, "save_mcp_server", None)
+        if not callable(delegate):
+            raise InvalidRequestError("MCP management is unavailable")
+        return await delegate(command)
+
+    async def delete_mcp_server(self, command: DeleteMcpServerCommand) -> McpServerListResult:
+        session = self._session_from_dto(
+            command, DeleteMcpServerCommand, "delete MCP server command"
+        )
+        self._authorize(session, MCP_WRITE)
+        delegate = getattr(self._delegate, "delete_mcp_server", None)
+        if not callable(delegate):
+            raise InvalidRequestError("MCP management is unavailable")
+        return await delegate(command)
+
     def watch_events(
         self,
         session: SessionRef,