iac-code 0.4.0__tar.gz → 0.4.1__tar.gz

{iac_code-0.4.0 → iac_code-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.4.0
+Version: 0.4.1
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

iac_code-0.4.1/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.4.1"
+__release_date__ = "2026-06-05"

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/a2a/executor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import os
 import uuid
@@ -27,7 +28,7 @@ from iac_code.a2a.types import (
 )
 from iac_code.services.agent_factory import AgentFactoryOptions, create_agent_runtime
 from iac_code.services.session_storage import SessionStorage
-from iac_code.services.telemetry import use_session_id
+from iac_code.services.telemetry import use_session_id, use_user_id
 
 logger = logging.getLogger(__name__)
 _CONTEXT_LOCK_ACQUIRE_TIMEOUT_SECONDS = 1
@@ -87,6 +88,7 @@ class IacCodeA2AExecutor(AgentExecutor):
                 getattr(context, "message", None), "metadata", None
             )
             cwd = self._resolve_cwd(metadata)
+            user_id = self._resolve_user_id(metadata)
             prompt = self._prompt_from_context(context, cwd=cwd)
         except Exception as exc:
             if _is_retryable_executor_error(exc):
@@ -222,7 +224,8 @@ class IacCodeA2AExecutor(AgentExecutor):
                     context_id=context_id,
                     state=TaskState.TASK_STATE_WORKING,
                 )
-                with use_session_id(ctx.session_id):
+                user_id_ctx = use_user_id(user_id) if user_id else contextlib.nullcontext()
+                with use_session_id(ctx.session_id), user_id_ctx:
                     async for event in runtime.agent_loop.run_streaming(prompt):
                         text_chunk = await publish_stream_event(
                             event_queue,
@@ -348,6 +351,19 @@ class IacCodeA2AExecutor(AgentExecutor):
             resolved_cwd.mkdir(parents=True, exist_ok=True)
         return str(resolved_cwd)
 
+    def _resolve_user_id(self, metadata: Any | None) -> str | None:
+        if metadata is not None and hasattr(metadata, "DESCRIPTOR"):
+            metadata = MessageToDict(metadata, preserving_proto_field_name=False)
+        if not isinstance(metadata, Mapping):
+            return None
+        raw_iac_meta = metadata.get("iac_code")
+        if not isinstance(raw_iac_meta, Mapping):
+            return None
+        raw_user_id = raw_iac_meta.get("user_id")
+        if isinstance(raw_user_id, str) and raw_user_id.strip():
+            return raw_user_id.strip()
+        return None
+
     def _prompt_from_context(self, context: RequestContext, *, cwd: str) -> str:
         message = getattr(context, "message", None)
         if not isinstance(message, Message):

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/acp/session.py

@@ -157,6 +157,20 @@ _PREFIX_ALLOW_RULE = "allow_rule:"
 _PREFIX_DENY_RULE = "deny_rule:"
 
 
+def _tool_supports_blanket_allow(agent_loop, tool_name: str) -> bool:
+    """Return False only when the registered tool explicitly disables blanket allow."""
+    registry = getattr(agent_loop, "tool_registry", None)
+    get_tool = getattr(registry, "get", None)
+    if get_tool is None:
+        return True
+
+    tool = get_tool(tool_name)
+    if tool is None:
+        return True
+
+    return bool(getattr(tool, "supports_blanket_allow", True))
+
+
 class ACPSession:
     def __init__(
         self,
@@ -457,7 +471,7 @@ class ACPSession:
                     kind="allow_always",
                 )
             )
-        else:
+        elif _tool_supports_blanket_allow(self.agent_loop, tool_name):
             options.append(
                 acp.schema.PermissionOption(
                     option_id=_OPTION_ALLOW_ALWAYS,

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/acp/tools.py

@@ -5,6 +5,7 @@ from contextlib import suppress
 
 import acp
 
+from iac_code.i18n import _
 from iac_code.tools.base import Tool, ToolContext, ToolResult
 
 TERMINAL_TIMEOUT = 300  # 5 minutes default timeout
@@ -32,9 +33,37 @@ class ACPTerminalBashTool(Tool):
     def timeout(self) -> float | None:
         return self._original.timeout
 
+    @property
+    def supports_blanket_allow(self) -> bool:
+        return self._original.supports_blanket_allow
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return self._original.user_facing_name(input)
+
+    def get_activity_description(self, input: dict | None = None) -> str | None:
+        return self._original.get_activity_description(input)
+
+    def get_tool_use_summary(self, input: dict | None = None) -> str | None:
+        return self._original.get_tool_use_summary(input)
+
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False) -> str | None:
+        return self._original.render_tool_use_message(input, verbose=verbose)
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False) -> str | None:
+        return self._original.render_tool_result_message(output, is_error=is_error, verbose=verbose)
+
+    def render_tool_use_error_message(self, error: str) -> str | None:
+        return self._original.render_tool_use_error_message(error)
+
+    def streaming_preview_fields(self) -> list[str]:
+        return self._original.streaming_preview_fields()
+
     def is_read_only(self, input: dict | None = None) -> bool:
         return self._original.is_read_only(input)
 
+    def is_concurrency_safe(self, tool_input: dict) -> bool:
+        return self._original.is_concurrency_safe(tool_input)
+
     def is_destructive(self, input: dict | None = None) -> bool:
         return self._original.is_destructive(input)
 
@@ -44,7 +73,7 @@ class ACPTerminalBashTool(Tool):
     async def execute(self, *, tool_input: dict, context: ToolContext) -> ToolResult:
         command = tool_input.get("command")
         if not command:
-            return ToolResult.error("Bash command is required.")
+            return ToolResult.error(_("Bash command is required."))
 
         timeout = tool_input.get("timeout", TERMINAL_TIMEOUT)
         terminal_id: str | None = None
@@ -74,7 +103,7 @@ class ACPTerminalBashTool(Tool):
             except asyncio.TimeoutError:
                 with suppress(Exception):
                     await self._conn.kill_terminal(session_id=self._session_id, terminal_id=terminal_id)
-                return ToolResult.error(f"Command timed out after {timeout} seconds")
+                return ToolResult.error(_("Command timed out after {timeout} seconds").format(timeout=timeout))
 
             if output.exit_status:
                 exit_status = output.exit_status
@@ -84,9 +113,15 @@ class ACPTerminalBashTool(Tool):
             # at the session layer in a future phase.
 
             if exit_status.signal:
-                return ToolResult.error(f"Command terminated by signal: {exit_status.signal}\n{output.output}")
+                return ToolResult.error(
+                    _("Command terminated by signal: {signal}").format(signal=exit_status.signal) + "\n" + output.output
+                )
             if exit_status.exit_code not in (None, 0):
-                return ToolResult.error(f"Command failed with exit code {exit_status.exit_code}\n{output.output}")
+                return ToolResult.error(
+                    _("Command failed with exit code {exit_code}").format(exit_code=exit_status.exit_code)
+                    + "\n"
+                    + output.output
+                )
             return ToolResult.success(output.output)
         except asyncio.CancelledError:
             if terminal_id is not None:

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/agent/agent_loop.py

@@ -6,7 +6,7 @@ import asyncio
 import os
 import time
 import uuid
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -23,6 +23,7 @@ from iac_code.types.stream_events import (
     CompactionEvent,
     MessageEndEvent,
     PermissionRequestEvent,
+    QueuedInputSubmittedEvent,
     StackInstancesProgressEvent,
     StackProgressEvent,
     StreamEvent,
@@ -94,6 +95,7 @@ class AgentLoop:
             model_name = provider_manager.get_model_name()
 
         self.context_manager = ContextManager(system_prompt=system_prompt, model=model_name)
+        self._sync_tool_definitions()
         if resume_messages:
             self.context_manager.load_messages(resume_messages)
         self._tool_executor = ToolExecutor(registry=tool_registry)
@@ -116,6 +118,7 @@ class AgentLoop:
         if system_prompt is not None:
             self.system_prompt = system_prompt
             self.context_manager.set_system_prompt(system_prompt)
+        self._sync_tool_definitions()
 
     def set_auto_trigger_skills(self, skill_commands: list[Any] | None) -> None:
         """Refresh skills considered for automatic trigger injection."""
@@ -136,6 +139,12 @@ class AgentLoop:
             )
         return tools
 
+    def _sync_tool_definitions(self):
+        """Refresh context token accounting from the current tool registry."""
+        tool_definitions = self._get_tool_definitions()
+        self.context_manager.set_tool_definitions(tool_definitions)
+        return tool_definitions
+
     def _get_provider_messages(self):
         """Convert context manager messages to provider Message format."""
         from iac_code.providers.base import ContentBlock
@@ -178,7 +187,11 @@ class AgentLoop:
                 final_text += event.text
         return final_text
 
-    async def run_streaming(self, user_input: str | list[ContentBlock]) -> AsyncGenerator[StreamEvent, None]:
+    async def run_streaming(
+        self,
+        user_input: str | list[ContentBlock],
+        queued_input_provider: Callable[[], list[str]] | None = None,
+    ) -> AsyncGenerator[StreamEvent, None]:
         """Streaming execution yielding fine-grained StreamEvents.
 
         Flow:
@@ -248,7 +261,10 @@ class AgentLoop:
                         git_branch=self._current_git_branch,
                     )
                 try:
-                    async for event in self._run_streaming_inner(user_input):
+                    async for event in self._run_streaming_inner(
+                        user_input,
+                        queued_input_provider=queued_input_provider,
+                    ):
                         if isinstance(event, TextDeltaEvent) and not first_token_received:
                             first_token_received = True
                             ttft_ns = int((time.monotonic() - interaction_started) * 1_000_000_000)
@@ -272,14 +288,18 @@ class AgentLoop:
                         serialize_output_messages("".join(final_text_chunks), final_stop_reason),
                     )
 
-    async def _run_streaming_inner(self, user_input: str | list[ContentBlock]) -> AsyncGenerator[StreamEvent, None]:
+    async def _run_streaming_inner(
+        self,
+        user_input: str | list[ContentBlock],
+        queued_input_provider: Callable[[], list[str]] | None = None,
+    ) -> AsyncGenerator[StreamEvent, None]:
         """Inner streaming loop (called from run_streaming inside the ENTRY span)."""
         from iac_code.services.telemetry import start_span
         from iac_code.services.telemetry.names import GenAiAttr, GenAiOperationName, GenAiSpanKind, Spans
 
-        tool_definitions = self._get_tool_definitions()
-
         for _turn in range(self._max_turns):
+            tool_definitions = self._sync_tool_definitions()
+
             # Auto-compact if needed
             if self.context_manager.needs_compaction():
                 compact_event = await self._auto_compact()
@@ -303,7 +323,7 @@ class AgentLoop:
                 async for event in self._provider_manager.stream(
                     messages=self._get_provider_messages(),
                     system=self.system_prompt,
-                    tools=tool_definitions if self.tool_registry.list_tools() else None,
+                    tools=tool_definitions if tool_definitions else None,
                 ):
                     yield event  # Forward all provider events to UI
 
@@ -329,6 +349,7 @@ class AgentLoop:
 
                 if not message_ended:
                     step_span.set_attribute(GenAiAttr.REACT_FINISH_REASON, "error")
+                    yield MessageEndEvent(stop_reason="stream_error", usage=Usage())
                     break
 
                 # Build assistant message for context
@@ -451,8 +472,13 @@ class AgentLoop:
 
                             denied_content: list[ContentBlock] = list(denied_blocks)
                             self._session_storage.append(
-                                self._cwd, self._session_id, Message(role="user", content=denied_content)
+                                self._cwd,
+                                self._session_id,
+                                Message(role="user", content=denied_content),
+                                git_branch=self._current_git_branch,
                             )
+                        async for event in self._submit_queued_inputs_after_tool_call(queued_input_provider):
+                            yield event
                     continue
 
                 requests = allowed_requests
@@ -549,9 +575,35 @@ class AgentLoop:
                             self.context_manager.add_raw_message(msg)
                     if result.context_modifier is not None:
                         self._apply_context_modifier(result.context_modifier)
+
+                async for event in self._submit_queued_inputs_after_tool_call(queued_input_provider):
+                    yield event
         else:
             yield MessageEndEvent(stop_reason="max_turns", usage=Usage())
 
+    async def _submit_queued_inputs_after_tool_call(
+        self,
+        queued_input_provider: Callable[[], list[str]] | None,
+    ) -> AsyncGenerator[QueuedInputSubmittedEvent, None]:
+        if queued_input_provider is None:
+            return
+
+        queued_inputs = queued_input_provider()
+        for raw_input in queued_inputs:
+            text = raw_input.strip()
+            if not text:
+                continue
+            await self._apply_auto_triggers(text)
+            message = self.context_manager.add_user_message(text)
+            if self._session_storage:
+                self._session_storage.append(
+                    self._cwd,
+                    self._session_id,
+                    message,
+                    git_branch=self._current_git_branch,
+                )
+            yield QueuedInputSubmittedEvent(text=text)
+
     async def _apply_auto_triggers(self, user_input: str | list[ContentBlock]) -> None:
         if not self._auto_trigger_skills:
             return

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/agent/agent_tool.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import asyncio
+from contextlib import suppress
 from dataclasses import dataclass
 from typing import Any
 
 from iac_code.agent.agent_types import filter_tools, get_agent_definition, get_builtin_agents
-from iac_code.i18n import _
+from iac_code.i18n import _, ngettext
 from iac_code.tools.base import Tool, ToolContext, ToolResult
 
 
@@ -21,6 +22,14 @@ class AgentProgress:
     summary: str = ""
 
 
+def _format_base_exception(error: BaseException) -> str:
+    detail = str(error)
+    error_type = type(error).__name__
+    if not detail:
+        return error_type
+    return "{error_type}: {detail}".format(error_type=error_type, detail=detail)
+
+
 async def run_sub_agent(
     *,
     prompt: str,
@@ -45,7 +54,7 @@ async def run_sub_agent(
 
     defn = get_agent_definition(agent_type)
     if defn is None:
-        raise ValueError(f"Unknown agent type: {agent_type}")
+        raise ValueError(_("Unknown agent type: {agent_type}").format(agent_type=agent_type))
 
     sub_registry = filter_tools(parent_tool_registry, defn) if parent_tool_registry else parent_tool_registry
     system_prompt = parent_system_prompt or build_system_prompt(cwd=cwd)
@@ -58,7 +67,7 @@ async def run_sub_agent(
         permission_context=permission_context,
     )
 
-    progress = AgentProgress(summary=f"Running {agent_type} agent")
+    progress = AgentProgress(summary=_("Running {agent_type} agent").format(agent_type=agent_type))
     text_chunks: list[str] = []
     # Track tool inputs: tool_use_id -> (name, input)
     pending_tool_inputs: dict[str, tuple[str, dict]] = {}
@@ -128,7 +137,6 @@ class AgentTool(Tool):
         self._tool_registry = tool_registry
         self._system_prompt = system_prompt
         self._permission_context = permission_context
-        self._event_queue: asyncio.Queue | None = None  # Set by ToolExecutor via ToolCallRequest
 
     @property
     def name(self) -> str:
@@ -137,8 +145,13 @@ class AgentTool(Tool):
     @property
     def description(self) -> str:
         agents = get_builtin_agents()
-        agent_list = "\n".join(f"  - {a.agent_type}: {a.when_to_use}" for a in agents)
-        return f"Launch a sub-agent to handle complex tasks.\n\nAvailable agent types:\n{agent_list}"
+        agent_list = "\n".join(
+            "  - {agent_type}: {when_to_use}".format(agent_type=agent.agent_type, when_to_use=agent.when_to_use)
+            for agent in agents
+        )
+        return _("Launch a sub-agent to handle complex tasks.\n\nAvailable agent types:\n{agent_list}").format(
+            agent_list=agent_list
+        )
 
     @property
     def input_schema(self) -> dict[str, Any]:
@@ -148,20 +161,20 @@ class AgentTool(Tool):
             "properties": {
                 "prompt": {
                     "type": "string",
-                    "description": "The task for the sub-agent to perform.",
+                    "description": _("The task for the sub-agent to perform."),
                 },
                 "description": {
                     "type": "string",
-                    "description": "Short (3-5 word) description of the task.",
+                    "description": _("Short (3-5 word) description of the task."),
                 },
                 "subagent_type": {
                     "type": "string",
                     "enum": agent_types,
-                    "description": "The type of specialized agent to use.",
+                    "description": _("The type of specialized agent to use."),
                 },
                 "run_in_background": {
                     "type": "boolean",
-                    "description": "Run agent in background, parent continues.",
+                    "description": _("Run agent in background, parent continues."),
                 },
             },
             "required": ["prompt", "description"],
@@ -171,18 +184,30 @@ class AgentTool(Tool):
         prompt = tool_input["prompt"]
         agent_type = tool_input.get("subagent_type", tool_input.get("agent_type", "general-purpose"))
         run_in_background = tool_input.get("run_in_background", False)
+        event_queue = context.event_queue
 
         defn = get_agent_definition(agent_type)
         if defn is None:
-            return ToolResult.error(f"Unknown agent type: '{agent_type}'")
+            return ToolResult.error(_("Unknown agent type: '{agent_type}'").format(agent_type=agent_type))
 
         if run_in_background and self._task_manager:
             task_id = self._task_manager.register(
-                description=tool_input.get("description", "Sub-agent task"),
+                description=tool_input.get("description", _("Sub-agent task")),
                 agent_type=agent_type,
             )
-            asyncio.create_task(self._run_background(task_id, prompt, agent_type, context))
-            return ToolResult.success(f"Background agent launched (task_id: {task_id}, type: {agent_type})")
+            background_task = asyncio.create_task(self._run_background(task_id, prompt, agent_type, context))
+            attach_task = getattr(self._task_manager, "attach_task", None)
+            if callable(attach_task):
+                attach_task(task_id, background_task)
+            background_task.add_done_callback(self._consume_background_task_exception)
+            if event_queue is not None:
+                await event_queue.put(None)
+            return ToolResult.success(
+                _("Background agent launched (task_id: {task_id}, type: {agent_type})").format(
+                    task_id=task_id,
+                    agent_type=agent_type,
+                )
+            )
 
         try:
             result_text, progress = await run_sub_agent(
@@ -192,18 +217,25 @@ class AgentTool(Tool):
                 parent_provider_manager=self._provider_manager,
                 parent_tool_registry=self._tool_registry,
                 parent_system_prompt=self._system_prompt,
-                event_queue=self._event_queue,
+                event_queue=event_queue,
                 permission_context=self._permission_context,
             )
-            if self._event_queue:
-                await self._event_queue.put(None)
+            if event_queue is not None:
+                await event_queue.put(None)
             return ToolResult.success(
                 f"{result_text}\n\n[Agent stats: {progress.tool_use_count} tool calls, {progress.token_count} tokens]"
             )
         except Exception as e:
-            if self._event_queue:
-                await self._event_queue.put(None)
-            return ToolResult.error(f"Sub-agent failed: {e}")
+            if event_queue is not None:
+                await event_queue.put(None)
+            return ToolResult.error(_("Sub-agent failed: {error}").format(error=e))
+
+    @staticmethod
+    def _consume_background_task_exception(task: asyncio.Task) -> None:
+        if task.cancelled():
+            return
+        with suppress(asyncio.CancelledError):
+            task.exception()
 
     async def _run_background(
         self,
@@ -231,15 +263,37 @@ class AgentTool(Tool):
             if self._notification_queue:
                 self._notification_queue.enqueue(
                     task_id=task_id,
-                    message=f"Agent completed: {progress.tool_use_count} tool calls",
+                    message=ngettext(
+                        "Agent completed: {tool_count} tool call",
+                        "Agent completed: {tool_count} tool calls",
+                        progress.tool_use_count,
+                    ).format(tool_count=progress.tool_use_count),
                 )
+        except asyncio.CancelledError:
+            self._task_manager.stop(task_id)
+            if self._notification_queue:
+                self._notification_queue.enqueue(
+                    task_id=task_id,
+                    message=_("Agent stopped"),
+                )
+            raise
         except Exception as e:
-            self._task_manager.fail(task_id, error=str(e))
+            error = str(e) or type(e).__name__
+            self._task_manager.fail(task_id, error=error)
+            if self._notification_queue:
+                self._notification_queue.enqueue(
+                    task_id=task_id,
+                    message=_("Agent failed: {error}").format(error=error),
+                )
+        except BaseException as e:
+            error = _format_base_exception(e)
+            self._task_manager.fail(task_id, error=error)
             if self._notification_queue:
                 self._notification_queue.enqueue(
                     task_id=task_id,
-                    message=f"Agent failed: {e}",
+                    message=_("Agent failed: {error}").format(error=error),
                 )
+            raise
 
     def is_read_only(self, input: dict | None = None) -> bool:
         return False
@@ -252,7 +306,7 @@ class AgentTool(Tool):
 
     def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False) -> str | None:
         if is_error:
-            return f"Agent error: {output[:200]}"
+            return _("Agent error: {error}").format(error=output[:200])
         if verbose:
             return output
         # Extract stats from the end of the output
@@ -282,4 +336,4 @@ class AgentTool(Tool):
     def get_activity_description(self, input: dict | None = None) -> str | None:
         if input is None:
             return None
-        return f"Running agent: {input.get('description', 'sub-agent')}"
+        return _("Running agent: {description}").format(description=input.get("description", _("sub-agent")))

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/agent/agent_types.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from iac_code.i18n import _
+
 if TYPE_CHECKING:
     from iac_code.tools.base import ToolRegistry
 
@@ -49,9 +51,9 @@ def get_builtin_agents() -> list[AgentDefinition]:
     return [
         AgentDefinition(
             agent_type="general-purpose",
-            when_to_use=(
-                "Use for complex, multi-step tasks that require research, "
-                "code changes, or coordinating multiple operations."
+            when_to_use=_(
+                "Use for complex, multi-step tasks that require research, code changes, "
+                "or coordinating multiple operations."
             ),
             tools=["*"],
             disallowed_tools=["agent"],
@@ -59,9 +61,9 @@ def get_builtin_agents() -> list[AgentDefinition]:
         ),
         AgentDefinition(
             agent_type="explore",
-            when_to_use=(
-                "Use to quickly find files, search code, or answer questions "
-                "about the codebase. Read-only — cannot modify files."
+            when_to_use=_(
+                "Use to quickly find files, search code, or answer questions about the codebase. "
+                "Read-only; cannot modify files."
             ),
             tools=["read_file", "glob", "grep", "list_files", "bash"],
             disallowed_tools=["write_file", "edit_file", "agent"],
@@ -69,9 +71,9 @@ def get_builtin_agents() -> list[AgentDefinition]:
         ),
         AgentDefinition(
             agent_type="plan",
-            when_to_use=(
-                "Use to plan implementation strategy, review architecture, "
-                "or design solutions. Read-only, no execution."
+            when_to_use=_(
+                "Use to plan implementation strategy, review architecture, or design solutions. "
+                "Read-only, no execution."
             ),
             tools=["read_file", "glob", "grep", "list_files"],
             disallowed_tools=["bash", "write_file", "edit_file", "agent"],

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/cli/main.py

@@ -28,6 +28,10 @@ completion_init()
 # this works regardless of where it's called relative to `import typer` / click.
 setup_i18n()
 
+# Import subcommands with Typer parameter help after i18n setup, because Typer
+# captures custom option help text when the function signature is defined.
+from iac_code.cli.update import update as _update_command  # noqa: E402
+
 app = typer.Typer(
     name="iac-code",
     help=_("AI-powered infrastructure orchestration tool"),
@@ -54,6 +58,8 @@ if sys.platform == "win32":
         help=_("Install Git for Windows via the npmmirror mirror (Windows only)."),
     )(_install_git_bash)
 
+app.command(name="update", help=_("Update iac-code to the latest version."))(_update_command)
+
 
 @a2a_client_app.callback()
 def a2a_client(

iac_code-0.4.1/src/iac_code/cli/update.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import shlex
+
+import typer
+
+from iac_code import __version__
+from iac_code.i18n import _
+from iac_code.services.update_checker import check_for_updates_once, run_update_command
+
+
+def update(
+    check: bool = typer.Option(False, "--check", help=_("Check for updates without installing.")),
+) -> None:
+    """Update iac-code to the latest available version."""
+    state = check_for_updates_once(current_version=__version__, force=True)
+    pending = state.pending
+    if pending is None:
+        typer.echo(_("iac-code is already up to date (v{}).").format(__version__))
+        raise typer.Exit()
+
+    if check:
+        typer.echo(_("Update available: v{} -> v{}").format(pending.current_version, pending.version))
+        typer.echo(_("Run {} to update.").format(shlex.join(pending.update_command)))
+        raise typer.Exit()
+
+    typer.echo(_("Updating iac-code from v{} to v{}...").format(pending.current_version, pending.version))
+    try:
+        result = run_update_command(pending)
+    except OSError as exc:
+        typer.echo(_("Update command failed: {}").format(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    if result.returncode != 0:
+        typer.echo(_("Update command failed with exit code {}.").format(result.returncode), err=True)
+        raise typer.Exit(result.returncode)
+
+    typer.echo(_("Successfully updated to v{}!").format(pending.version))

{iac_code-0.4.0 → iac_code-0.4.1}/src/iac_code/commands/auth.py

@@ -1400,6 +1400,8 @@ def _aliyun_oauth_login_flow(existing_cred: "AliyunCredential | None") -> str |
         return _BACK
     except AliyunOAuthError as exc:
         return _("Alibaba Cloud OAuth login failed: {error}").format(error=str(exc))
+    finally:
+        client.close()
 
     credential = AliyunCredential(
         mode="OAuth",