[#24244] Added logic to restore terminator profile once VulcanAI exec finish

Signed-off-by: danipiza <dpizarrogallego@gmail.com>

Author: Danipiza

src/vulcanai/console/terminal_session.py

@@ -190,6 +190,120 @@ def _run(*args: str) -> bool:
 
         return completed.returncode == 0
 
+    @staticmethod
+    def _run_capture(*args: str) -> Optional[str]:
+        """
+        Execute a command and return trimmed stdout on success.
+
+        @return stdout without trailing whitespace, or ``None`` on failure/empty output.
+        """
+        try:
+            completed = subprocess.run(
+                [*args],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+        except Exception:
+            return None
+
+        if completed.returncode != 0:
+            return None
+
+        output = (completed.stdout or "").strip()
+        return output or None
+
+    @staticmethod
+    def _parse_profile_name(raw_output: Optional[str]) -> Optional[str]:
+        """
+        Extract profile name from ``remotinator`` output.
+        """
+        if not raw_output:
+            return None
+
+        lines = [line.strip() for line in raw_output.splitlines() if line.strip()]
+        if not lines:
+            return None
+
+        candidate = lines[-1].strip("'\"")
+        lower_candidate = candidate.lower()
+        for prefix in ("current profile:", "profile:", "profile="):
+            if lower_candidate.startswith(prefix):
+                candidate = candidate[len(prefix) :].strip().strip("'\"")
+                break
+
+        return candidate or None
+
+    def _get_current_profile(self, terminal_uuid: str) -> Optional[str]:
+        """
+        Query current profile for a terminal UUID using ``remotinator``.
+        """
+        output = self._run_capture("remotinator", "get_profile", "-u", terminal_uuid)
+        return self._parse_profile_name(output)
+
+    @staticmethod
+    def _profiles_block_bounds(lines: list[str]) -> Optional[tuple[int, int]]:
+        """
+        Locate the [profiles] block bounds in Terminator config lines.
+        """
+        profiles_start = next((i for i, line in enumerate(lines) if line.strip() == "[profiles]"), None)
+        if profiles_start is None:
+            return None
+
+        profiles_end = len(lines)
+        for index in range(profiles_start + 1, len(lines)):
+            if TerminatorTerminalAdapter._TOP_LEVEL_SECTION_RE.match(lines[index]) and lines[index].strip() != "[profiles]":
+                profiles_end = index
+                break
+
+        return (profiles_start, profiles_end)
+
+    @classmethod
+    def _list_profiles(cls, config_path: Path) -> list[str]:
+        """
+        Return profile names defined in the Terminator config.
+        """
+        try:
+            lines = config_path.read_text(encoding="utf-8").splitlines(keepends=True)
+        except Exception:
+            return []
+
+        bounds = cls._profiles_block_bounds(lines)
+        if not bounds:
+            return []
+
+        profiles_start, profiles_end = bounds
+        names: list[str] = []
+        for index in range(profiles_start + 1, profiles_end):
+            header_match = cls._PROFILE_HEADER_RE.match(lines[index].rstrip("\r\n"))
+            if header_match:
+                names.append(header_match.group(2).strip())
+        return names
+
+    def _fallback_restore_profile(self, config_path: Path) -> Optional[str]:
+        """
+        Pick a best-effort restore profile when runtime query is unavailable.
+        """
+        profiles = [name for name in self._list_profiles(config_path) if name != self._config.terminator_profile_hidden]
+        if not profiles:
+            return None
+
+        configured_base = self._config.terminator_profile_base
+        if configured_base in profiles and configured_base != "default":
+            return configured_base
+
+        non_default = [name for name in profiles if name != "default"]
+        if configured_base == "default" and len(non_default) == 1 and "default" in profiles:
+            return non_default[0]
+
+        if configured_base in profiles:
+            return configured_base
+        if len(non_default) == 1:
+            return non_default[0]
+        if "default" in profiles:
+            return "default"
+        return profiles[0]
+
     @staticmethod
     def _config_path() -> Path:
         """
@@ -212,15 +326,10 @@ def _ensure_hidden_profile(cls, config_path: Path, base_profile: str, hidden_pro
         except Exception:
             return False
 
-        profiles_start = next((i for i, line in enumerate(lines) if line.strip() == "[profiles]"), None)
-        if profiles_start is None:
+        bounds = cls._profiles_block_bounds(lines)
+        if not bounds:
             return False
-
-        profiles_end = len(lines)
-        for index in range(profiles_start + 1, len(lines)):
-            if cls._TOP_LEVEL_SECTION_RE.match(lines[index]) and lines[index].strip() != "[profiles]":
-                profiles_end = index
-                break
+        profiles_start, profiles_end = bounds
 
         profile_headers: list[tuple[str, int, str]] = []
         for index in range(profiles_start + 1, profiles_end):
@@ -298,7 +407,7 @@ def detect(self) -> bool:
     def apply(self) -> Optional[tuple[str, str]]:
         """
         @brief Switch current Terminator tab to hidden-scroll profile.
-        @return ``(uuid, base_profile)`` when switching succeeds, else ``None``.
+        @return ``(uuid, restore_profile)`` when switching succeeds, else ``None``.
         """
         terminal_uuid = os.environ.get("TERMINATOR_UUID")
         if not terminal_uuid:
@@ -311,12 +420,28 @@ def apply(self) -> Optional[tuple[str, str]]:
         if not config_path.is_file():
             return None
 
+        restore_profile = self._get_current_profile(terminal_uuid)
+        if not restore_profile:
+            # Older remotinator versions do not expose the active profile.
+            # Use a config-based best effort so profile switching still works.
+            restore_profile = self._fallback_restore_profile(config_path)
+        if not restore_profile:
+            return None
+
         if not self._ensure_hidden_profile(
             config_path=config_path,
-            base_profile=self._config.terminator_profile_base,
+            base_profile=restore_profile,
             hidden_profile=self._config.terminator_profile_hidden,
         ):
-            return None
+            # Fallback to configured profile in case runtime query is unavailable or untrusted.
+            if restore_profile == self._config.terminator_profile_base:
+                return None
+            if not self._ensure_hidden_profile(
+                config_path=config_path,
+                base_profile=self._config.terminator_profile_base,
+                hidden_profile=self._config.terminator_profile_hidden,
+            ):
+                return None
 
         switched = self._run(
             "remotinator",
@@ -329,7 +454,7 @@ def apply(self) -> Optional[tuple[str, str]]:
         if not switched:
             return None
 
-        return (terminal_uuid, self._config.terminator_profile_base)
+        return (terminal_uuid, restore_profile)
 
     def restore(self, state: Optional[tuple[str, str]]) -> None:
         """

src/vulcanai/core/plan_types.py

@@ -115,7 +115,7 @@ def __str__(self) -> str:
                     + f"<{color_value}>{node.timeout_ms} ms</{color_value}>"
                 )
             if node.success_criteria:
-                #     Succes Criteria: <node.success_criteria>
+                #     Success Criteria: <node.success_criteria>
                 lines.append(
                     f"\t<{color_tool}>Success Criteria</{color_tool}>: "
                     + f"<{color_value}>{node.success_criteria}</{color_value}>"