forgexa-cli 1.48.4__tar.gz → 1.49.0__tar.gz

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.48.4
+Version: 1.49.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.48.4"
+__version__ = "1.49.0"

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/forgexa_cli/agent_core.py

@@ -319,6 +319,21 @@ class AgentDiscovery:
             ),
             "upgrade_hint": "opencode upgrade",
         },
+        "mimo": {
+            "commands": ["mimo"],
+            "detect": "mimo --version",
+            "invoke_modes": ["cli"],
+            "env_path_override": "FACTORY_MIMO_PATH",
+            "env_model_override": "FACTORY_MIMO_MODEL",
+            "compatibility_level": "L2",
+            "min_version": (0, 1, 14),
+            "min_version_reason": (
+                "The Runtime Daemon relies on the verified `mimo run --format json` "
+                "protocol and non-interactive permission flag introduced by MiMo Code "
+                "v0.1.14."
+            ),
+            "upgrade_hint": "mimo upgrade",
+        },
         "gemini": {
             "commands": ["gemini"],
             "detect": "gemini --version",
@@ -380,6 +395,7 @@ class AgentDiscovery:
             extra_dirs += [
                 appdata / "npm",                         # npm -g installs
                 home / ".opencode" / "bin",
+                home / ".mimocode" / "bin",
                 home / ".cargo" / "bin",
                 home / ".bun" / "bin",
                 home / "scoop" / "shims",                # scoop package manager
@@ -422,6 +438,7 @@ class AgentDiscovery:
             extra_dirs += [
                 home / ".local" / "bin",         # pip / pipx installs, Claude Code
                 home / ".opencode" / "bin",      # opencode
+                home / ".mimocode" / "bin",      # MiMo Code
                 home / ".cargo" / "bin",         # Rust / cargo installs
                 home / ".bun" / "bin",           # bun
                 home / ".volta" / "bin",         # volta (node version manager)
@@ -658,6 +675,14 @@ class AgentDiscovery:
 # ── Advisory file locks ──
 
 
+def mimo_profile_lock_path() -> Path:
+    """Return the machine-local lock shared by all MiMo Code processes."""
+    override = os.environ.get("FORGEXA_MIMO_PROFILE_LOCK", "").strip()
+    if override:
+        return Path(override)
+    return Path.home() / ".forgexa" / "locks" / "mimo-profile.lock"
+
+
 def acquire_file_lock(
     path: str | Path,
     *,
@@ -1616,6 +1641,77 @@ def build_opencode_command(
     return cmd
 
 
+def build_mimo_command(
+    binary: str,
+    *,
+    cwd: str | Path,
+    model: str | None = None,
+    prompt_file: str | Path | None = None,
+    session_id: str | None = None,
+    prompt: str | None = None,
+) -> list[str]:
+    """MiMo Code CLI non-interactive invocation for the local AgentHost."""
+    cmd = [
+        binary, "run",
+        "--format", "json",
+        "--dangerously-skip-permissions",
+        "--dir", str(cwd),
+    ]
+    if session_id:
+        cmd += ["--session", session_id]
+    if model:
+        cmd += ["--model", model]
+    if prompt_file is not None:
+        cmd += [
+            "--file", str(prompt_file),
+            "--", "Read and follow the attached instructions.",
+        ]
+    elif prompt is not None:
+        cmd += ["--", prompt]
+    return cmd
+
+
+def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
+    """Return the constrained MiMo Code environment used by AgentHost turns."""
+    env = dict(env)
+    env.update({
+        "MIMOCODE_DISABLE_SHARE": "true",
+        "MIMOCODE_ENABLE_ANALYSIS": "false",
+        "MIMOCODE_PURE": "true",
+        "MIMOCODE_DISABLE_DEFAULT_PLUGINS": "true",
+        "MIMOCODE_DISABLE_PROJECT_CONFIG": "true",
+        "MIMOCODE_DISABLE_EXTERNAL_SKILLS": "true",
+        "MIMOCODE_DISABLE_LSP_DOWNLOAD": "true",
+        "MIMOCODE_DISABLE_CLAUDE_CODE_MCP": "true",
+        "MIMOCODE_DISABLE_AUTOUPDATE": "true",
+        "MIMOCODE_MIMO_ONLY": "true",
+        "MIMOCODE_PERMISSION": json.dumps({
+            "*": "deny",
+            "read": "allow",
+            "edit": "allow",
+            "glob": "allow",
+            "grep": "allow",
+            "lsp": "allow",
+            "bash": {
+                "*": "allow",
+                "git commit*": "deny",
+                "git * commit*": "deny",
+                "git push*": "deny",
+                "git * push*": "deny",
+                "git reset --hard*": "deny",
+                "git * reset --hard*": "deny",
+            },
+            "external_directory": "deny",
+            "task": "deny",
+            "skill": "deny",
+            "webfetch": "deny",
+            "websearch": "deny",
+            "codesearch": "deny",
+        }, separators=(",", ":")),
+    })
+    return env
+
+
 def opencode_base_env(
     env: dict[str, str], *, data_home: str | Path, require_windows_shell: bool = False,
 ) -> dict[str, str]:

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/forgexa_cli/daemon.py

@@ -1120,7 +1120,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.48.4"
+DAEMON_VERSION = "1.49.0"
 
 
 def _detect_client_type() -> str:
@@ -1934,7 +1934,7 @@ def _daemon_extract_agent_output(agent_id: str, raw: str) -> str:
         return _daemon_extract_copilot_output(raw)
     if agent_id == "codex":
         return _daemon_extract_codex_output(raw)
-    if agent_id == "opencode":
+    if agent_id in ("opencode", "mimo"):
         return _daemon_extract_opencode_output(raw)
     return raw
 
@@ -5640,6 +5640,10 @@ class ProcessManager:
             result = await self._run_codex(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         elif agent.agent_id == "opencode":
             result = await self._run_opencode(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
+        elif agent.agent_id == "mimo":
+            result = await self._run_mimo(
+                agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
+            )
         elif agent.agent_id == "gemini":
             result = await self._run_gemini(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         elif agent.agent_id == "kimi":
@@ -6379,6 +6383,53 @@ class ProcessManager:
         result.metrics.update(parsed_metrics)
         return result
 
+    async def _run_mimo(
+        self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
+        on_chunk: Any = None,
+    ) -> TaskResult:
+        """Run MiMo Code with its user-managed profile serialized machine-wide.
+
+        MiMo's native sessions, memory and credentials belong to its own profile.
+        Unlike OpenCode, do not redirect XDG/MIMOCODE_HOME or copy auth files per
+        task: that would break its state model and risk credential handling bugs.
+        The shared lock covers AgentHost and Daemon processes using that profile.
+        """
+        profile_lock = agent_core.acquire_file_lock(agent_core.mimo_profile_lock_path())
+        if profile_lock is None:
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout="",
+                stderr="",
+                error=(
+                    "MiMo Code profile is busy with another local turn; retry after it "
+                    "finishes"
+                ),
+                failure_code="mimo_profile_busy",
+            )
+
+        tmp_root = tempfile.mkdtemp(prefix=f"mimo-{task_id[:8]}-")
+        try:
+            prompt_file = Path(tmp_root) / "instructions.md"
+            prompt_file.write_text(prompt, encoding="utf-8")
+            cmd = agent_core.build_mimo_command(
+                agent.command,
+                cwd=cwd,
+                model=os.environ.get("FACTORY_MIMO_MODEL", "").strip() or None,
+                prompt_file=prompt_file,
+            )
+            env = agent_core.mimo_base_env(os.environ.copy())
+            result = await self._run_cli(
+                cmd, cwd, timeout, task_id, on_chunk=on_chunk, env=env,
+            )
+        finally:
+            agent_core.release_file_lock(profile_lock)
+            shutil.rmtree(tmp_root, ignore_errors=True)
+
+        parsed_metrics = self._parse_agent_jsonl_output(result.stdout)
+        result.metrics.update(parsed_metrics)
+        return result
+
     async def _run_gemini(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -7830,7 +7881,7 @@ class HeartbeatService:
 
     def update(self, active_tasks: int, agents: list[dict]):
         self._active_tasks = active_tasks
-        self._agents = agents
+        self._agents = [dict(agent) for agent in agents]
 
     async def _sync_local_workspace_bindings(self) -> None:
         try:
@@ -8143,6 +8194,8 @@ class ServerConnection:
         self.poller: TaskPoller | None = None
         self.reporter: ProgressReporter | None = None
         self.log_uploader: LogUploader | None = None
+        self._agents: list[DiscoveredAgent] = []
+        self._max_concurrent = 5
         self._auth_failures = 0  # Consecutive auth failure count
         self._max_auth_failures = 3  # Trigger re-registration after this many
         # Set when the server demands a runtime credential (compat window
@@ -8568,7 +8621,19 @@ class ServerConnection:
             self._re_register_lock = asyncio.Lock()
         return self._re_register_lock
 
-    async def re_register(self, agents: list[DiscoveredAgent], max_concurrent: int):
+    def update_agent_inventory(
+        self, active_tasks: int, agents: list[DiscoveredAgent],
+    ) -> None:
+        """Keep heartbeat and re-registration on one current agent snapshot."""
+        self._agents = list(agents)
+        if self.heartbeat:
+            self.heartbeat.update(active_tasks, _agent_dicts_for_wire(self._agents))
+
+    async def re_register(
+        self,
+        agents: list[DiscoveredAgent] | None = None,
+        max_concurrent: int | None = None,
+    ):
         """Refresh token and re-register with the server.
 
         Called when persistent auth failures indicate stale token/hash.
@@ -8578,6 +8643,10 @@ class ServerConnection:
         Single-flight: concurrent triggers (heartbeat/poller/poll_ai_jobs all
         share the auth-failure callback) collapse into one execution.
         """
+        if agents is not None:
+            self._agents = list(agents)
+        if max_concurrent is not None:
+            self._max_concurrent = max_concurrent
         lock = self._get_re_register_lock()
         if lock.locked():
             logger.debug(
@@ -8588,7 +8657,7 @@ class ServerConnection:
         async with lock:
             await self.refresh_access_token()
             try:
-                await self.register(agents, max_concurrent)
+                await self.register(self._agents, self._max_concurrent)
                 # Sync runtime_id to all services (may change after re-registration)
                 if self.heartbeat and self.runtime_id:
                     self.heartbeat.runtime_id = self.runtime_id
@@ -8610,9 +8679,10 @@ class ServerConnection:
 
     async def register(self, agents: list[DiscoveredAgent], max_concurrent: int):
         """Register this daemon with the server."""
-        self._agents = agents
+        self._agents = list(agents)
+        self._max_concurrent = max_concurrent
         self._max_concurrent_cache = max_concurrent
-        agent_dicts = _agent_dicts_for_wire(agents)
+        agent_dicts = _agent_dicts_for_wire(self._agents)
         async def _register_once():
             payload = {
                 "daemon_id": self.daemon_id,
@@ -8685,7 +8755,7 @@ class ServerConnection:
         preflight_snapshot_provider: Callable[[], dict | None] | None = None,
     ):
         """Initialize heartbeat, poller, and reporter services."""
-        self._agents = agents
+        self._agents = list(agents)
         self._max_concurrent = getattr(self, '_max_concurrent_cache', 5)
 
         def _on_auth_success():
@@ -8708,7 +8778,7 @@ class ServerConnection:
                 try:
                     loop = asyncio.get_event_loop()
                     if loop.is_running():
-                        loop.create_task(self.re_register(self._agents, self._max_concurrent))
+                        loop.create_task(self.re_register())
                 except Exception:
                     pass
 
@@ -8719,7 +8789,7 @@ class ServerConnection:
         )
         self.heartbeat._on_success = _on_heartbeat_success
         self.heartbeat._on_auth_failure = _on_auth_failure
-        self.heartbeat.update(0, _agent_dicts_for_wire(agents))
+        self.update_agent_inventory(0, self._agents)
         self.poller = TaskPoller(
             self.client, self.server_url, self.runtime_id, poll_interval,
         )
@@ -9354,10 +9424,8 @@ class RuntimeDaemon:
         logger.info("Refreshed agent inventory: %s -> %s", previous_agents, current_agents)
 
         active_tasks = len(self.active_tasks)
-        agent_dicts = self._agents_as_dicts()
         for connection in self.connections:
-            if connection.heartbeat:
-                connection.heartbeat.update(active_tasks, agent_dicts)
+            connection.update_agent_inventory(active_tasks, refreshed_agents)
 
     async def _agent_refresh_loop(self) -> None:
         while not self._shutdown:
@@ -10238,8 +10306,7 @@ class RuntimeDaemon:
         # Update heartbeat on all connections with total active count
         total_active = len(self.active_tasks)
         for conn in self.connections:
-            if conn.heartbeat:
-                conn.heartbeat.update(total_active, self._agents_as_dicts())
+            conn.update_agent_inventory(total_active, self.agents)
 
         # Poll from all connected servers
         for conn in self.connections:
@@ -10637,6 +10704,7 @@ class RuntimeDaemon:
                     "claude": "npm install -g @anthropic-ai/claude-code",
                     "codex": "npm install -g @openai/codex",
                     "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "mimo": "curl -fsSL https://mimo.xiaomi.com/install | bash",
                     "gemini": "npm install -g @google/gemini-cli",
                     "kimi": "curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash",
                     "copilot": (
@@ -11683,9 +11751,11 @@ class RuntimeDaemon:
             for agent in self.agents:
                 if agent.agent_id == preferred_id:
                     return agent
-        # 3. Any remaining agent
+        # 3. Any remaining agent. MiMo Code requires explicit selection or an
+        # explicit policy fallback entry; it must never become an implicit
+        # catch-all because its profile state is shared machine-wide.
         for agent in self.agents:
-            if agent.agent_id not in tried:
+            if agent.agent_id not in tried and agent.agent_id != "mimo":
                 return agent
 
         return None
@@ -11728,8 +11798,9 @@ class RuntimeDaemon:
         for agent in self.agents:
             if agent.compatibility_level == "L3":
                 return agent
-        # 5. Any agent (last resort for unrecognized types)
-        return self.agents[0] if self.agents else None
+        # 5. Any agent (last resort for unrecognized types), excluding the
+        # explicit-only MiMo Code driver.
+        return next((agent for agent in self.agents if agent.agent_id != "mimo"), None)
 
     # ── Layer 2: Validation Gate ──
 
@@ -13043,6 +13114,7 @@ class RuntimeDaemon:
                     "claude": "npm install -g @anthropic-ai/claude-code",
                     "codex": "npm install -g @openai/codex",
                     "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "mimo": "curl -fsSL https://mimo.xiaomi.com/install | bash",
                     "gemini": "npm install -g @google/gemini-cli",
                     "kimi": "curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash",
                     "copilot": (

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.48.4
+Version: 1.49.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.48.4 → forgexa_cli-1.49.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.48.4"
+version = "1.49.0"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"