wcgw 5.4.5__py3-none-any.whl → 5.5.1__py3-none-any.whl

wcgw/client/bash_state/bash_state.py

@@ -3,13 +3,15 @@ import json
 import os
 import platform
 import random
+import re
+import shlex
 import subprocess
 import tempfile
 import threading
 import time
 import traceback
 from dataclasses import dataclass
-from hashlib import sha256
+from hashlib import md5, sha256
 from typing import (
     Any,
     Literal,
@@ -17,6 +19,7 @@ from typing import (
     ParamSpec,
     TypeVar,
 )
+from uuid import uuid4
 
 import pexpect
 import psutil
@@ -36,8 +39,9 @@ from ..encoder import EncoderDecoder
 from ..modes import BashCommandMode, FileEditMode, WriteIfEmptyMode
 from .parser.bash_statement_parser import BashStatementParser
 
-PROMPT_CONST = "wcgw→" + " "
-PROMPT_STATEMENT = "export GIT_PAGER=cat PAGER=cat PROMPT_COMMAND= PS1='wcgw→'' '"
+PROMPT_CONST = re.compile(r"◉ ([^\n]*)──➤")
+PROMPT_COMMAND = "printf '◉ '\"$(pwd)\"'──➤'' \r\\e[2K'"
+PROMPT_STATEMENT = ""
 BASH_CLF_OUTPUT = Literal["repl", "pending"]
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
@@ -85,8 +89,23 @@ def get_tmpdir() -> str:
 def check_if_screen_command_available() -> bool:
     try:
         subprocess.run(
-            ["which", "screen"], capture_output=True, check=True, timeout=0.2
+            ["which", "screen"],
+            capture_output=True,
+            check=True,
+            timeout=CONFIG.timeout,
         )
+
+        # Check if screenrc exists, create it if it doesn't
+        home_dir = os.path.expanduser("~")
+        screenrc_path = os.path.join(home_dir, ".screenrc")
+
+        if not os.path.exists(screenrc_path):
+            screenrc_content = """defscrollback 10000
+termcapinfo xterm* ti@:te@
+"""
+            with open(screenrc_path, "w") as f:
+                f.write(screenrc_content)
+
         return True
     except (subprocess.CalledProcessError, FileNotFoundError, TimeoutError):
         return False
@@ -215,7 +234,7 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
             capture_output=True,
             text=True,
             check=True,
-            timeout=0.2,
+            timeout=CONFIG.timeout,
         )
         output = result.stdout
     except subprocess.CalledProcessError as e:
@@ -252,18 +271,112 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
             console.log(f"Failed to kill screen session: {session}\n{e}")
 
 
+def get_rc_file_path(shell_path: str) -> Optional[str]:
+    """
+    Get the rc file path for the given shell.
+
+    Args:
+        shell_path: Path to the shell executable
+
+    Returns:
+        Path to the rc file or None if not supported
+    """
+    shell_name = os.path.basename(shell_path)
+    home_dir = os.path.expanduser("~")
+
+    if shell_name == "zsh":
+        return os.path.join(home_dir, ".zshrc")
+    elif shell_name == "bash":
+        return os.path.join(home_dir, ".bashrc")
+    else:
+        return None
+
+
+def ensure_wcgw_block_in_rc_file(shell_path: str, console: Console) -> None:
+    """
+    Ensure the WCGW environment block exists in the appropriate rc file.
+
+    Args:
+        shell_path: Path to the shell executable
+        console: Console for logging
+    """
+    rc_file_path = get_rc_file_path(shell_path)
+    if not rc_file_path:
+        return
+
+    shell_name = os.path.basename(shell_path)
+
+    # Define the WCGW block with marker comments
+    marker_start = "# --WCGW_ENVIRONMENT_START--"
+    marker_end = "# --WCGW_ENVIRONMENT_END--"
+
+    if shell_name == "zsh":
+        wcgw_block = f"""{marker_start}
+if [ -n "$IN_WCGW_ENVIRONMENT" ]; then
+ PROMPT_COMMAND='printf "◉ $(pwd)──➤ \\r\\e[2K"'
+ prmptcmdwcgw() {{ eval "$PROMPT_COMMAND" }}
+ add-zsh-hook -d precmd prmptcmdwcgw
+ precmd_functions+=prmptcmdwcgw
+fi
+{marker_end}
+"""
+    elif shell_name == "bash":
+        wcgw_block = f"""{marker_start}
+if [ -n "$IN_WCGW_ENVIRONMENT" ]; then
+ PROMPT_COMMAND='printf "◉ $(pwd)──➤ \\r\\e[2K"'
+fi
+{marker_end}
+"""
+    else:
+        return
+
+    # Check if rc file exists
+    if not os.path.exists(rc_file_path):
+        # Create the rc file with the WCGW block
+        try:
+            with open(rc_file_path, "w") as f:
+                f.write(wcgw_block)
+            console.log(f"Created {rc_file_path} with WCGW environment block")
+        except Exception as e:
+            console.log(f"Failed to create {rc_file_path}: {e}")
+        return
+
+    # Check if the block already exists
+    try:
+        with open(rc_file_path) as f:
+            content = f.read()
+
+        if marker_start in content:
+            # Block already exists
+            return
+
+        # Append the block to the file
+        with open(rc_file_path, "a") as f:
+            f.write("\n" + wcgw_block)
+        console.log(f"Added WCGW environment block to {rc_file_path}")
+    except Exception as e:
+        console.log(f"Failed to update {rc_file_path}: {e}")
+
+
 def start_shell(
-    is_restricted_mode: bool, initial_dir: str, console: Console, over_screen: bool
+    is_restricted_mode: bool,
+    initial_dir: str,
+    console: Console,
+    over_screen: bool,
+    shell_path: str,
 ) -> tuple["pexpect.spawn[str]", str]:
-    cmd = "/bin/bash"
-    if is_restricted_mode:
+    cmd = shell_path
+    if is_restricted_mode and cmd.split("/")[-1] == "bash":
         cmd += " -r"
 
     overrideenv = {
         **os.environ,
-        "PS1": PROMPT_CONST,
+        "PROMPT_COMMAND": PROMPT_COMMAND,
         "TMPDIR": get_tmpdir(),
         "TERM": "xterm-256color",
+        "IN_WCGW_ENVIRONMENT": "1",
+        "GIT_PAGER": "cat",
+        "PAGER": "cat",
     }
     try:
         shell = pexpect.spawn(
@@ -277,7 +390,7 @@ def start_shell(
             dimensions=(500, 160),
         )
         shell.sendline(PROMPT_STATEMENT)  # Unset prompt command to avoid interfering
-        shell.expect(PROMPT_CONST, timeout=0.2)
+        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
     except Exception as e:
         console.print(traceback.format_exc())
         console.log(f"Error starting shell: {e}. Retrying without rc ...")
@@ -291,30 +404,31 @@ def start_shell(
             codec_errors="backslashreplace",
         )
         shell.sendline(PROMPT_STATEMENT)
-        shell.expect(PROMPT_CONST, timeout=0.2)
+        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
 
-    shellid = "wcgw." + time.strftime("%H%M%S")
+    initialdir_hash = md5(
+        os.path.normpath(os.path.abspath(initial_dir)).encode()
+    ).hexdigest()[:5]
+    shellid = shlex.quote(
+        "wcgw."
+        + time.strftime("%d-%Hh%Mm%Ss")
+        + f".{initialdir_hash[:3]}."
+        + os.path.basename(initial_dir)
+    )
     if over_screen:
         if not check_if_screen_command_available():
             raise ValueError("Screen command not available")
         # shellid is just hour, minute, second number
-        shell.sendline(f"trap 'screen -X -S {shellid} quit' EXIT")
-        shell.expect(PROMPT_CONST, timeout=0.2)
-
-        shell.sendline(f"screen -q -S {shellid} /bin/bash --noprofile --norc")
+        while True:
+            output = shell.expect([PROMPT_CONST, pexpect.TIMEOUT], timeout=0.1)
+            if output == 1:
+                break
+        shell.sendline(f"screen -q -S {shellid} {shell_path}")
         shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
 
     return shell, shellid
 
 
-def _is_int(mystr: str) -> bool:
-    try:
-        int(mystr)
-        return True
-    except ValueError:
-        return False
-
-
 def render_terminal_output(text: str) -> list[str]:
     screen = pyte.Screen(160, 500)
     screen.set_mode(pyte.modes.LNM)
@@ -390,8 +504,9 @@ class BashState:
         use_screen: bool,
         whitelist_for_overwrite: Optional[dict[str, "FileWhitelistData"]] = None,
         thread_id: Optional[str] = None,
+        shell_path: Optional[str] = None,
     ) -> None:
-        self._last_command: str = ""
+        self.last_command: str = ""
         self.console = console
         self._cwd = working_dir or os.getcwd()
         # Store the workspace root separately from the current working directory
@@ -403,7 +518,7 @@ class BashState:
         self._write_if_empty_mode: WriteIfEmptyMode = (
             write_if_empty_mode or WriteIfEmptyMode("all")
         )
-        self._mode = mode or "wcgw"
+        self._mode: Modes = mode or "wcgw"
         self._whitelist_for_overwrite: dict[str, FileWhitelistData] = (
             whitelist_for_overwrite or {}
         )
@@ -414,31 +529,78 @@ class BashState:
         self._bg_expect_thread: Optional[threading.Thread] = None
         self._bg_expect_thread_stop_event = threading.Event()
         self._use_screen = use_screen
+        # Ensure shell_path is always a str, never None
+        self._shell_path: str = (
+            shell_path if shell_path else os.environ.get("SHELL", "/bin/bash")
+        )
+        if get_rc_file_path(self._shell_path) is None:
+            console.log(
+                f"Warning: Unsupported shell: {self._shell_path}, defaulting to /bin/bash"
+            )
+            self._shell_path = "/bin/bash"
+
+        self.background_shells = dict[str, BashState]()
         self._init_shell()
 
-    def expect(self, pattern: Any, timeout: Optional[float] = -1) -> int:
+    def start_new_bg_shell(self, working_dir: str) -> "BashState":
+        cid = uuid4().hex[:10]
+        state = BashState(
+            self.console,
+            working_dir=working_dir,
+            bash_command_mode=self.bash_command_mode,
+            file_edit_mode=self.file_edit_mode,
+            write_if_empty_mode=self.write_if_empty_mode,
+            mode=self.mode,
+            use_screen=self.over_screen,
+            whitelist_for_overwrite=None,
+            thread_id=cid,
+            shell_path=self._shell_path,
+        )
+        self.background_shells[cid] = state
+        return state
+
+    def expect(
+        self, pattern: Any, timeout: Optional[float] = -1, flush_rem_prompt: bool = True
+    ) -> int:
         self.close_bg_expect_thread()
         try:
             output = self._shell.expect(pattern, timeout)
+            if isinstance(self._shell.match, re.Match) and self._shell.match.groups():
+                cwd = self._shell.match.group(1)
+                if cwd.strip():
+                    self._cwd = cwd
+                    # We can safely flush current prompt
+                    if flush_rem_prompt:
+                        temp_before = self._shell.before
+                        self.flush_prompt()
+                        self._shell.before = temp_before
         except pexpect.TIMEOUT:
             # Edge case: gets raised when the child fd is not ready in some timeout
             # pexpect/utils.py:143
             return 1
         return output
 
+    def flush_prompt(self) -> None:
+        # Flush remaining prompt
+        for _ in range(200):
+            try:
+                output = self.expect([" ", pexpect.TIMEOUT], 0.1)
+                if output == 1:
+                    return
+            except pexpect.TIMEOUT:
+                return
+
     def send(self, s: str | bytes, set_as_command: Optional[str]) -> int:
-        self.close_bg_expect_thread()
         if set_as_command is not None:
-            self._last_command = set_as_command
+            self.last_command = set_as_command
         # if s == "\n":
         #     return self._shell.sendcontrol("m")
         output = self._shell.send(s)
         return output
 
     def sendline(self, s: str | bytes, set_as_command: Optional[str]) -> int:
-        self.close_bg_expect_thread()
         if set_as_command is not None:
-            self._last_command = set_as_command
+            self.last_command = set_as_command
         output = self._shell.sendline(s)
         return output
 
@@ -453,8 +615,8 @@ class BashState:
     @property
     def before(self) -> Optional[str]:
         before = self._shell.before
-        if before and before.startswith(self._last_command):
-            return before[len(self._last_command) :]
+        if before and before.startswith(self.last_command):
+            return before[len(self.last_command) :]
         return before
 
     def run_bg_expect_thread(self) -> None:
@@ -477,6 +639,8 @@ class BashState:
             target=_bg_expect_thread_handler,
         )
         self._bg_expect_thread.start()
+        for k, v in self.background_shells.items():
+            v.run_bg_expect_thread()
 
     def close_bg_expect_thread(self) -> None:
         if self._bg_expect_thread:
@@ -484,9 +648,10 @@ class BashState:
             self._bg_expect_thread.join()
             self._bg_expect_thread = None
             self._bg_expect_thread_stop_event = threading.Event()
+        for k, v in self.background_shells.items():
+            v.close_bg_expect_thread()
 
     def cleanup(self) -> None:
-        cleanup_all_screens_with_name(self._shell_id, self.console)
         self.close_bg_expect_thread()
         self._shell.close(True)
 
@@ -512,45 +677,15 @@ class BashState:
     def write_if_empty_mode(self) -> WriteIfEmptyMode:
         return self._write_if_empty_mode
 
-    def ensure_env_and_bg_jobs(self) -> Optional[int]:
-        quick_timeout = 0.2 if not self.over_screen else 1
-        # First reset the prompt in case venv was sourced or other reasons.
-        self.sendline(PROMPT_STATEMENT, set_as_command=PROMPT_STATEMENT)
-        self.expect(PROMPT_CONST, timeout=quick_timeout)
-        # Reset echo also if it was enabled
-        command = "jobs | wc -l"
-        self.sendline(command, set_as_command=command)
-        before = ""
-        counts = 0
-        while not _is_int(before):  # Consume all previous output
-            try:
-                self.expect(PROMPT_CONST, timeout=quick_timeout)
-            except pexpect.TIMEOUT:
-                self.console.print(f"Couldn't get exit code, before: {before}")
-                raise
-
-            before_val = self.before
-            if not isinstance(before_val, str):
-                before_val = str(before_val)
-            assert isinstance(before_val, str)
-            before_lines = render_terminal_output(before_val)
-            before = "\n".join(before_lines).replace(command, "").strip()
-            counts += 1
-            if counts > 100:
-                raise ValueError(
-                    "Error in understanding shell output. This shouldn't happen, likely shell is in a bad state, please reset it"
-                )
-        try:
-            return int(before)
-        except ValueError:
-            raise ValueError(f"Malformed output: {before}")
-
     def _init_shell(self) -> None:
         self._state: Literal["repl"] | datetime.datetime = "repl"
-        self._last_command = ""
+        self.last_command = ""
         # Ensure self._cwd exists
         os.makedirs(self._cwd, exist_ok=True)
 
+        # Ensure WCGW block exists in rc file
+        ensure_wcgw_block_in_rc_file(self._shell_path, self.console)
+
         # Clean up orphaned WCGW screen sessions
         if check_if_screen_command_available():
             cleanup_orphaned_wcgw_screens(self.console)
@@ -561,6 +696,7 @@ class BashState:
                 self._cwd,
                 self.console,
                 over_screen=self._use_screen,
+                shell_path=self._shell_path,
             )
             self.over_screen = self._use_screen
         except Exception as e:
@@ -573,14 +709,11 @@ class BashState:
                 self._cwd,
                 self.console,
                 over_screen=False,
+                shell_path=self._shell_path,
             )
             self.over_screen = False
 
         self._pending_output = ""
-        try:
-            self.ensure_env_and_bg_jobs()
-        except ValueError as e:
-            self.console.log("Error while running _ensure_env_and_bg_jobs" + str(e))
 
         self.run_bg_expect_thread()
 
@@ -592,7 +725,40 @@ class BashState:
     def set_repl(self) -> None:
         self._state = "repl"
         self._pending_output = ""
-        self._last_command = ""
+        self.last_command = ""
+
+    def clear_to_run(self) -> None:
+        """Check if prompt is clear to enter new command otherwise send ctrl c"""
+        # First clear
+        starttime = time.time()
+        self.close_bg_expect_thread()
+        try:
+            while True:
+                try:
+                    output = self.expect(
+                        [PROMPT_CONST, pexpect.TIMEOUT], 0.1, flush_rem_prompt=False
+                    )
+                    if output == 1:
+                        break
+                except pexpect.TIMEOUT:
+                    break
+                if time.time() - starttime > CONFIG.timeout:
+                    self.console.log(
+                        f"Error: could not clear output in {CONFIG.timeout} seconds. Resetting"
+                    )
+                    self.reset_shell()
+                    return
+            output = self.expect([" ", pexpect.TIMEOUT], 0.1)
+            if output != 1:
+                # Then we got something new send ctrl-c
+                self.send("\x03", None)
+
+                output = self.expect([PROMPT_CONST, pexpect.TIMEOUT], CONFIG.timeout)
+                if output == 1:
+                    self.console.log("Error: could not clear output. Resetting")
+                    self.reset_shell()
+        finally:
+            self.run_bg_expect_thread()
 
     @property
     def state(self) -> BASH_CLF_OUTPUT:
@@ -614,22 +780,9 @@ class BashState:
         self._workspace_root = workspace_root
 
     @property
-    def prompt(self) -> str:
+    def prompt(self) -> re.Pattern[str]:
         return PROMPT_CONST
 
-    def update_cwd(self) -> str:
-        self.sendline("pwd", set_as_command="pwd")
-        self.expect(PROMPT_CONST, timeout=0.2)
-        before_val = self.before
-        if not isinstance(before_val, str):
-            before_val = str(before_val)
-        before_lines = render_terminal_output(before_val)
-        current_dir = "\n".join(before_lines).strip()
-        if current_dir.startswith("pwd"):
-            current_dir = current_dir[3:].strip()
-        self._cwd = current_dir
-        return current_dir
-
     def reset_shell(self) -> None:
         self.cleanup()
         self._init_shell()
@@ -964,19 +1117,21 @@ def _incremental_text(text: str, last_pending_output: str) -> str:
     return rstrip(rendered)
 
 
-def get_status(bash_state: BashState) -> str:
+def get_status(bash_state: BashState, is_bg: bool) -> str:
     status = "\n\n---\n\n"
+    if is_bg:
+        status += f"bg_command_id = {bash_state.current_thread_id}\n"
     if bash_state.state == "pending":
         status += "status = still running\n"
         status += "running for = " + bash_state.get_pending_for() + "\n"
         status += "cwd = " + bash_state.cwd + "\n"
     else:
-        bg_jobs = bash_state.ensure_env_and_bg_jobs()
         bg_desc = ""
-        if bg_jobs and bg_jobs > 0:
-            bg_desc = f"; {bg_jobs} background jobs running"
         status += "status = process exited" + bg_desc + "\n"
-        status += "cwd = " + bash_state.update_cwd() + "\n"
+        status += "cwd = " + bash_state.cwd + "\n"
+
+    if not is_bg:
+        status += "This is the main shell. " + get_bg_running_commandsinfo(bash_state)
 
     return status.rstrip()
 
@@ -1022,9 +1177,47 @@ def execute_bash(
 
     finally:
         bash_state.run_bg_expect_thread()
+        if bash_state.over_screen:
+            thread = threading.Thread(
+                target=cleanup_orphaned_wcgw_screens,
+                args=(bash_state.console,),
+                daemon=True,
+            )
+            thread.start()
     return output, cost
 
 
+def assert_single_statement(command: str) -> None:
+    # Check for multiple statements using the bash statement parser
+    if "\n" in command:
+        try:
+            parser = BashStatementParser()
+            statements = parser.parse_string(command)
+        except Exception:
+            # Fall back to simple newline check if something goes wrong
+            raise ValueError(
+                "Command should not contain newline character in middle. Run only one command at a time."
+            )
+        if len(statements) > 1:
+            raise ValueError(
+                "Error: Command contains multiple statements. Please run only one bash statement at a time."
+            )
+
+
+def get_bg_running_commandsinfo(bash_state: BashState) -> str:
+    msg = ""
+    running = []
+    for id_, state in bash_state.background_shells.items():
+        running.append(f"Command: {state.last_command}, bg_command_id: {id_}")
+    if running:
+        msg = (
+            "Following background commands are attached:\n" + "\n".join(running) + "\n"
+        )
+    else:
+        msg = "No command running in background.\n"
+    return msg
+
+
 def _execute_bash(
     bash_state: BashState,
     enc: EncoderDecoder[int],
@@ -1035,6 +1228,21 @@ def _execute_bash(
     try:
         is_interrupt = False
         command_data = bash_arg.action_json
+        is_bg = False
+        og_bash_state = bash_state
+
+        if not isinstance(command_data, Command) and command_data.bg_command_id:
+            if command_data.bg_command_id not in bash_state.background_shells:
+                error = f"No shell found running with command id {command_data.bg_command_id}.\n"
+                if bash_state.background_shells:
+                    error += get_bg_running_commandsinfo(bash_state)
+                if bash_state.state == "pending":
+                    error += f"On the main thread a command is already running ({bash_state.last_command})"
+                else:
+                    error += "On the main thread no command is running."
+                raise Exception(error)
+            bash_state = bash_state.background_shells[command_data.bg_command_id]
+            is_bg = True
 
         if isinstance(command_data, Command):
             if bash_state.bash_command_mode.allowed_commands == "none":
@@ -1047,26 +1255,16 @@ def _execute_bash(
 
             command = command_data.command.strip()
 
-            # Check for multiple statements using the bash statement parser
-            if "\n" in command:
-                try:
-                    parser = BashStatementParser()
-                    statements = parser.parse_string(command)
-                    if len(statements) > 1:
-                        return (
-                            "Error: Command contains multiple statements. Please run only one bash statement at a time.",
-                            0.0,
-                        )
-                except Exception:
-                    # Fall back to simple newline check if something goes wrong
-                    raise ValueError(
-                        "Command should not contain newline character in middle. Run only one command at a time."
-                    )
+            assert_single_statement(command)
 
-            for i in range(0, len(command), 128):
-                bash_state.send(command[i : i + 128], set_as_command=None)
-            bash_state.send(bash_state.linesep, set_as_command=command)
+            if command_data.is_background:
+                bash_state = bash_state.start_new_bg_shell(bash_state.cwd)
+                is_bg = True
 
+            bash_state.clear_to_run()
+            for i in range(0, len(command), 64):
+                bash_state.send(command[i : i + 64], set_as_command=None)
+            bash_state.send(bash_state.linesep, set_as_command=command)
         elif isinstance(command_data, StatusCheck):
             bash_state.console.print("Checking status")
             if bash_state.state != "pending":
@@ -1100,7 +1298,7 @@ def _execute_bash(
                 elif char == "Key-right":
                     bash_state.send("\033[C", set_as_command=None)
                 elif char == "Enter":
-                    bash_state.send("\n", set_as_command=None)
+                    bash_state.send("\x0d", set_as_command=None)
                 elif char == "Ctrl-c":
                     bash_state.sendintr()
                     is_interrupt = True
@@ -1187,8 +1385,14 @@ You may want to try Ctrl-c again or program specific exit interactive commands.
     """
                 )
 
-            exit_status = get_status(bash_state)
+            exit_status = get_status(bash_state, is_bg)
             incremental_text += exit_status
+            if is_bg and bash_state.state == "repl":
+                try:
+                    bash_state.cleanup()
+                    og_bash_state.background_shells.pop(bash_state.current_thread_id)
+                except Exception as e:
+                    bash_state.console.log(f"error while cleaning up {e}")
 
             return incremental_text, 0
 
@@ -1202,8 +1406,14 @@ You may want to try Ctrl-c again or program specific exit interactive commands.
         output = "(...truncated)\n" + enc.decoder(tokens[-(max_tokens - 1) :])
 
     try:
-        exit_status = get_status(bash_state)
+        exit_status = get_status(bash_state, is_bg)
         output += exit_status
+        if is_bg and bash_state.state == "repl":
+            try:
+                bash_state.cleanup()
+                og_bash_state.background_shells.pop(bash_state.current_thread_id)
+            except Exception as e:
+                bash_state.console.log(f"error while cleaning up {e}")
     except ValueError:
         bash_state.console.print(output)
         bash_state.console.print(traceback.format_exc())

wcgw/client/diff-instructions.txt

@@ -59,13 +59,15 @@ def call_hello_renamed():
 ```
 
 # *SEARCH/REPLACE block* Rules:
+Every "<<<<<<< SEARCH" section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, whitespaces, etc.
+
+Including multiple unique *SEARCH/REPLACE* blocks if needed.
+Include enough and only enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+
+Keep *SEARCH/REPLACE* blocks concise.
+Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
+Include just the changing lines, and a few surrounding lines (0-3 lines) if needed for uniqueness.
+Other than for uniqueness, avoid including those lines which do not change in search (and replace) blocks. Target 0-3 non trivial extra lines per block.
+
+Preserve leading spaces and indentations in both SEARCH and REPLACE blocks.
 
-- Every "SEARCH" section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, whitespaces, etc.
-- Use multiple search/replace blocks in a single FileWriteOrEdit tool call to edit in a single file in multiple places from top to bottom (separate calls are slower).
-- Including multiple unique *SEARCH/REPLACE* blocks if needed.
-- Include enough and only enough lines in each SEARCH section to uniquely match each set of lines that need to change.
-- Keep *SEARCH/REPLACE* blocks concise.
-- Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
-- Include just the changing lines, and a few surrounding lines (0-3 lines) if needed for uniqueness.
-- Other than for uniqueness, avoid including those lines which do not change in search (and replace) blocks. Target 0-3 non trivial extra lines per block.
-- Preserve leading spaces and indentations in both SEARCH and REPLACE blocks.

wcgw/client/mcp_server/__init__.py

@@ -15,6 +15,9 @@ def app(
     version: bool = typer.Option(
         False, "--version", "-v", help="Show version and exit"
     ),
+    shell: str = typer.Option(
+        "", "--shell", help="Path to shell executable (defaults to $SHELL or /bin/bash)"
+    ),
 ) -> None:
     """Main entry point for the package."""
     if version:
@@ -22,7 +25,7 @@ def app(
         print(f"wcgw version: {version_}")
         raise typer.Exit()
 
-    asyncio.run(server.main())
+    asyncio.run(server.main(shell))
 
 
 # Optionally expose other important items at package level

wcgw/client/mcp_server/server.py

@@ -151,7 +151,7 @@ BASH_STATE = None
 CUSTOM_INSTRUCTIONS = None
 
 
-async def main() -> None:
+async def main(shell_path: str = "") -> None:
     global BASH_STATE, CUSTOM_INSTRUCTIONS
     CONFIG.update(3, 55, 5)
     version = str(importlib.metadata.version("wcgw"))
@@ -164,7 +164,7 @@ async def main() -> None:
     starting_dir = os.path.join(tmp_dir, "claude_playground")
 
     with BashState(
-        Console(), starting_dir, None, None, None, None, True, None
+        Console(), starting_dir, None, None, None, None, True, None, None, shell_path or None
     ) as BASH_STATE:
         BASH_STATE.console.log("wcgw version: " + version)
         # Run the server using stdin/stdout streams

wcgw/client/modes.py

@@ -86,7 +86,7 @@ You are now running in "code_writer" mode.
 
     run_command_common = """
     - Do not use Ctrl-c interrupt commands without asking the user, because often the programs don't show any update but they still are running.
-    - Do not use echo to write multi-line files, always use FileWriteOrEdit tool to update a code.
+    - Do not use echo/cat to write any file, always use FileWriteOrEdit tool to create/update files.
     - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
     - You should use the provided bash execution, reading and writing file tools to complete objective.
     - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools.
@@ -120,7 +120,8 @@ WCGW_PROMPT = """
     - Do not install new tools/packages before ensuring no such tools/package or an alternative already exists.
     - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools
     - Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
-    - Do not use echo to write multi-line files, always use FileWriteOrEdit tool to update a code.
+    - Do not use echo/cat to write any file, always use FileWriteOrEdit tool to create/update files.
+    - You can share task summary directly without creating any file.
     - Provide as many file paths as you need in ReadFiles in one go.
 
 Additional instructions:

wcgw/client/tool_prompts.py

@@ -42,12 +42,14 @@ TOOL_PROMPTS = [
 - Status of the command and the current working directory will always be returned at the end.
 - The first or the last line might be `(...truncated)` if the output is too long.
 - Always run `pwd` if you get any file or directory not found error to make sure you're not lost.
-- Run long running commands in background using screen instead of "&".
-- Do not use 'cat' to read files, use ReadFiles tool instead
+- Do not run bg commands using "&", instead use this tool.
+- You must not use echo/cat to read/write files, use ReadFiles/FileWriteOrEdit
 - In order to check status of previous command, use `status_check` with empty command argument.
 - Only command is allowed to run at a time. You need to wait for any previous command to finish before running a new one.
 - Programs don't hang easily, so most likely explanation for no output is usually that the program is still running, and you need to check status again.
 - Do not send Ctrl-c before checking for status till 10 minutes or whatever is appropriate for the program to finish.
+- Only run long running commands in background. Each background command is run in a new non-reusable shell.
+- On running a bg command you'll get a bg command id that you should use to get status or interact.
 """,
         annotations=ToolAnnotations(destructiveHint=True, openWorldHint=True),
     ),

wcgw/client/tools.py

@@ -392,7 +392,7 @@ def reset_wcgw(
             f"Reset successful with mode change to {mode_name}.\n"
             + mode_prompt
             + "\n"
-            + get_status(context.bash_state)
+            + get_status(context.bash_state, is_bg=False)
         )
     else:
         # Regular reset without mode change - keep same mode but update directory
@@ -412,7 +412,7 @@ def reset_wcgw(
             starting_directory,
             thread_id,
         )
-    return "Reset successful" + get_status(context.bash_state)
+    return "Reset successful" + get_status(context.bash_state, is_bg=False)
 
 
 T = TypeVar("T")
@@ -1374,24 +1374,23 @@ if __name__ == "__main__":
         print(
             get_tool_output(
                 Context(BASH_STATE, BASH_STATE.console),
-                ReadFiles(
-                    file_paths=["/Users/arusia/repos/wcgw/src/wcgw/client/tools.py"],
+                BashCommand(
+                    action_json=Command(command="source .venv/bin/activate"),
+                    thread_id=BASH_STATE.current_thread_id,
                 ),
                 default_enc,
                 0,
                 lambda x, y: ("", 0),
                 24000,  # coding_max_tokens
                 8000,  # noncoding_max_tokens
-            )[0][0]
+            )
         )
 
         print(
             get_tool_output(
                 Context(BASH_STATE, BASH_STATE.console),
-                FileWriteOrEdit(
-                    file_path="/Users/arusia/repos/wcgw/src/wcgw/client/tools.py",
-                    text_or_search_replace_blocks="""test""",
-                    percentage_to_change=100,
+                BashCommand(
+                    action_json=Command(command="pwd"),
                     thread_id=BASH_STATE.current_thread_id,
                 ),
                 default_enc,
@@ -1399,5 +1398,35 @@ if __name__ == "__main__":
                 lambda x, y: ("", 0),
                 24000,  # coding_max_tokens
                 8000,  # noncoding_max_tokens
-            )[0][0]
+            )
+        )
+
+        print(
+            get_tool_output(
+                Context(BASH_STATE, BASH_STATE.console),
+                BashCommand(
+                    action_json=Command(command="take src"),
+                    thread_id=BASH_STATE.current_thread_id,
+                ),
+                default_enc,
+                0,
+                lambda x, y: ("", 0),
+                24000,  # coding_max_tokens
+                8000,  # noncoding_max_tokens
+            )
+        )
+
+        print(
+            get_tool_output(
+                Context(BASH_STATE, BASH_STATE.console),
+                BashCommand(
+                    action_json=Command(command="pwd"),
+                    thread_id=BASH_STATE.current_thread_id,
+                ),
+                default_enc,
+                0,
+                lambda x, y: ("", 0),
+                24000,  # coding_max_tokens
+                8000,  # noncoding_max_tokens
+            )
         )

wcgw/types_.py

@@ -86,16 +86,19 @@ class Initialize(BaseModel):
 class Command(BaseModel):
     command: str
     type: Literal["command"] = "command"
+    is_background: bool = False
 
 
 class StatusCheck(BaseModel):
     status_check: Literal[True] = True
     type: Literal["status_check"] = "status_check"
+    bg_command_id: str | None = None
 
 
 class SendText(BaseModel):
     send_text: str
     type: Literal["send_text"] = "send_text"
+    bg_command_id: str | None = None
 
 
 Specials = Literal[
@@ -106,11 +109,13 @@ Specials = Literal[
 class SendSpecials(BaseModel):
     send_specials: Sequence[Specials]
     type: Literal["send_specials"] = "send_specials"
+    bg_command_id: str | None = None
 
 
 class SendAscii(BaseModel):
     send_ascii: Sequence[int]
     type: Literal["send_ascii"] = "send_ascii"
+    bg_command_id: str | None = None
 
 
 class ActionJsonSchema(BaseModel):
@@ -132,6 +137,14 @@ class ActionJsonSchema(BaseModel):
     send_ascii: Optional[Sequence[int]] = Field(
         default=None, description='Set only if type="send_ascii"'
     )
+    is_background: bool = Field(
+        default=False,
+        description='Set only if type="command" and running the command in background',
+    )
+    bg_command_id: str | None = Field(
+        default=None,
+        description='Set only if type!="command" and doing action on a running background command',
+    )
 
 
 class BashCommandOverride(BaseModel):

{wcgw-5.4.5.dist-info → wcgw-5.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 5.4.5
+Version: 5.5.1
 Summary: Shell and coding agent for Claude and other mcp clients
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
@@ -49,6 +49,8 @@ wcgw is an MCP server with tightly integrated shell and code editing tools.
 
 ## Updates
 
+- [6 Oct 2025] Model can now run multiple commands in background. ZSH is now a supported shell. Multiplexing improvements.
+
 - [27 Apr 2025] Removed support for GPTs over relay server. Only MCP server is supported in version >= 5.
 
 - [24 Mar 2025] Improved writing and editing experience for sonnet 3.7, CLAUDE.md gets loaded automatically.
@@ -77,16 +79,16 @@ wcgw is an MCP server with tightly integrated shell and code editing tools.
   - File edit has spacing tolerant matching, with warning on issues like indentation mismatch. If there's no match, the closest match is returned to the AI to fix its mistakes.
   - Using Aider-like search and replace, which has better performance than tool call based search and replace.
 - ⚡ **Shell optimizations**:
-  - Only one command is allowed to be run at a time, simplifying management and avoiding rogue processes. There's only single shell instance at any point of time.
   - Current working directory is always returned after any shell command to prevent AI from getting lost.
   - Command polling exits after a quick timeout to avoid slow feedback. However, status checking has wait tolerance based on fresh output streaming from a command. Both of these approach combined provides a good shell interaction experience.
+  - Supports multiple concurrent background commands alongside the main interactive shell.
 - ⚡ **Saving repo context in a single file**: Task checkpointing using "ContextSave" tool saves detailed context in a single file. Tasks can later be resumed in a new chat asking "Resume `task id`". The saved file can be used to do other kinds of knowledge transfer, such as taking help from another AI.
 - ⚡ **Easily switch between various modes**:
   - Ask it to run in 'architect' mode for planning. Inspired by adier's architect mode, work with Claude to come up with a plan first. Leads to better accuracy and prevents premature file editing.
   - Ask it to run in 'code-writer' mode for code editing and project building. You can provide specific paths with wild card support to prevent other files getting edited.
   - By default it runs in 'wcgw' mode that has no restrictions and full authorisation.
   - More details in [Modes section](#modes)
-- ⚡ **Runs in multiplex terminal** Run `screen -x` to attach to the terminal that the AI runs commands on. See history or interrupt process or interact with the same terminal that AI uses.
+- ⚡ **Runs in multiplex terminal** Use [vscode extension](https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw) or run `screen -x` to attach to the terminal that the AI runs commands on. See history or interrupt process or interact with the same terminal that AI uses.
 - ⚡ **Automatically load CLAUDE.md/AGENTS.md** Loads "CLAUDE.md" or "AGENTS.md" file in project root and sends as instructions during initialisation. Instructions in a global "~/.wcgw/CLAUDE.md" or "~/.wcgw/AGENTS.md" file are loaded and added along with project specific CLAUDE.md. The file name is case sensitive. CLAUDE.md is attached if it's present otherwise AGENTS.md is attached.
 
 ## Top use cases examples
@@ -118,8 +120,8 @@ Then create or update `claude_desktop_config.json` (~/Library/Application Suppor
 {
   "mcpServers": {
     "wcgw": {
-      "command": "uv",
-      "args": ["tool", "run", "--python", "3.12", "wcgw"]
+      "command": "uvx",
+      "args": ["wcgw@latest"]
     }
   }
 }
@@ -127,6 +129,21 @@ Then create or update `claude_desktop_config.json` (~/Library/Application Suppor
 
 Then restart claude app.
 
+**Optional: Force a specific shell**
+
+To use a specific shell (bash or zsh), add the `--shell` argument:
+
+```json
+{
+  "mcpServers": {
+    "wcgw": {
+      "command": "uvx",
+      "args": ["wcgw@latest", "--shell", "/bin/bash"]
+    }
+  }
+}
+```
+
 _If there's an error in setting up_
 
 - If there's an error like "uv ENOENT", make sure `uv` is installed. Then run 'which uv' in the terminal, and use its output in place of "uv" in the configuration.
@@ -148,7 +165,7 @@ Then add or update the claude config file `%APPDATA%\Claude\claude_desktop_confi
   "mcpServers": {
     "wcgw": {
       "command": "wsl.exe",
-      "args": ["uv", "tool", "run", "--python", "3.12", "wcgw"]
+      "args": ["uvx", "wcgw@latest"]
     }
   }
 }
@@ -210,6 +227,9 @@ Note: in code-writer mode either all commands are allowed or none are allowed fo
 
 #### Attach to the working terminal to investigate
 
+NEW: the [vscode extension](https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw) now automatically attach the running terminal
+if workspace path matches.
+
 If you've `screen` command installed, wcgw runs on a screen instance automatically. If you've started wcgw mcp server, you can list the screen sessions:
 
 `screen -ls`
@@ -220,7 +240,7 @@ You can then attach to the session using `screen -x 93358.wcgw.235521`
 
 You may interrupt any running command safely.
 
-You can interact with the terminal but beware that the AI might be running in parallel and it may conflict with what you're doing. It's recommended to keep your interactions to minimum.
+You can interact with the terminal safely, for example for entering passwords, or entering some text. (Warning: If you run a new command, any new LLM command will interrupt it.)
 
 You shouldn't exit the session using `exit `or Ctrl-d, instead you should use `ctrl+a+d` to safely detach without destroying the screen session.
 

{wcgw-5.4.5.dist-info → wcgw-5.5.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 wcgw/__init__.py,sha256=JgAY25VsA208v8E7QTIU0E50nsk-TCJ4FWTEHmnssYU,127
 wcgw/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcgw/types_.py,sha256=dvFpZPywqczpX7Sv6-e-r0WZxOZ0Eu10DlpSLtl9zJs,9607
+wcgw/types_.py,sha256=sSgmWC8ciQ7b6yarVzmYGad81h7jlPK_XyftT28HerA,10104
 wcgw/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wcgw/client/common.py,sha256=OCH7Tx64jojz3M3iONUrGMadE07W21DiZs5sOxWX1Qc,1456
-wcgw/client/diff-instructions.txt,sha256=wCmB-Vj8HNSTvxjZIH0fX_J7v9jbsJOJeNj46Un1AJ0,1858
+wcgw/client/diff-instructions.txt,sha256=EU9WmJMbsmAj07CyuGWL6zd4eVQ8Ie3HZzd0k0WugX0,1687
 wcgw/client/memory.py,sha256=U2Nw2si3Zg7n_RhNAuaYcmrrDtZ_Mooi-kfAOKflT-I,3079
-wcgw/client/modes.py,sha256=roH6SPBokJMr5IzAlccdI-vJyvyS5vqSMMyth7TE86A,10315
+wcgw/client/modes.py,sha256=3eS5ttttltKAZB41h7-XwtdjMVYrUtd6xMush7k_vvw,10388
 wcgw/client/schema_generator.py,sha256=mEIy6BgHlfJeAjJtwY_VwoIDmu-Fax2H9bVtj7IMuEo,2282
-wcgw/client/tool_prompts.py,sha256=1EFQZeXlebOvrDb9t4g63FyzRWCnTwDzwrqwPHg-7sE,4757
-wcgw/client/tools.py,sha256=J_Ofbs7jBQXLfS4x9d7gZtTxNiaVbAmc0puCiyum9Ls,50038
-wcgw/client/bash_state/bash_state.py,sha256=bd5RtLbaRzCtrmeDTl3JKZwzmIR-8iAMQpl7Fqyt56M,41918
+wcgw/client/tool_prompts.py,sha256=zi4L98DwNePr5Yhwx7wl4jAgmlMjILPnKTLZGf0L4SA,4971
+wcgw/client/tools.py,sha256=YTjtAPSR8divbfDDOII9-iZG6B1ucPemdZ5pef6lEyQ,50904
+wcgw/client/bash_state/bash_state.py,sha256=tVVaUwSw2st9vPEkGQPbA0Qtb4gbgjCmP1TGgSQ_hU8,48872
 wcgw/client/bash_state/parser/__init__.py,sha256=AnlNSmoQTSoqqlLOLX4P1uXfzc5VGeCGJsGgtisq2zE,207
 wcgw/client/bash_state/parser/bash_statement_parser.py,sha256=9a8vPO1r3_tXmaAcubTQ5UY-NseWlalgm8LZA17LXuY,6058
 wcgw/client/encoder/__init__.py,sha256=Y-8f43I6gMssUCWpX5rLYiAFv3D-JPRs4uNEejPlke8,1514
@@ -17,8 +17,8 @@ wcgw/client/file_ops/diff_edit.py,sha256=AwLq6-pY7czv1y-JA5O2Q4rgbvn82YmSL9jD8XB
 wcgw/client/file_ops/extensions.py,sha256=CmfD7ON6SY24Prh2tRZdV9KbhuOrWqqk8qL1VtshzB8,3608
 wcgw/client/file_ops/search_replace.py,sha256=5LFg-_U_ijnNrkYei4SWCPGKPGgDzJs49EDsIBzLmuY,6822
 wcgw/client/mcp_server/Readme.md,sha256=2Z88jj1mf9daYGW1CWaldcJ0moy8owDumhR2glBY3A8,109
-wcgw/client/mcp_server/__init__.py,sha256=rSNET0SVjUTDn2HAfREisTXTBs89TVsWegDfYFMvy5w,621
-wcgw/client/mcp_server/server.py,sha256=RgsMDmNuYyg4VT1KorcLzh1Xfv49QASi0-FTLz_tlIo,5525
+wcgw/client/mcp_server/__init__.py,sha256=be5D_r2HNhWAi8uX2qz28z1hSjh_rfUDqqeBVyEyzkk,753
+wcgw/client/mcp_server/server.py,sha256=qREy9CQckvpLYx1VaujDljK6eTQSLA53C8KuK8dkU3U,5571
 wcgw/client/repo_ops/display_tree.py,sha256=g282qCKLCwo8O9NHUBnkG_NkIusroVzz3NZi8VIcmAI,4066
 wcgw/client/repo_ops/file_stats.py,sha256=AUA0Br7zFRpylWFYZPGMeGPJy3nWp9e2haKi34JptHE,4887
 wcgw/client/repo_ops/path_prob.py,sha256=SWf0CDn37rtlsYRQ51ufSxay-heaQoVIhr1alB9tZ4M,2144
@@ -27,12 +27,12 @@ wcgw/client/repo_ops/paths_tokens.model,sha256=jiwwE4ae8ADKuTZISutXuM5Wfyc_FBmN5
 wcgw/client/repo_ops/repo_context.py,sha256=e_w-1VfxWQiZT3r66N13nlmPt6AGm0uvG3A7aYSgaCI,9632
 wcgw_cli/__init__.py,sha256=TNxXsTPgb52OhakIda9wTRh91cqoBqgQRx5TxjzQQFU,21
 wcgw_cli/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
-wcgw_cli/anthropic_client.py,sha256=8bjDY59-aioyTJgpB-NBHZNhZaq6rqcTJcOf81kzCyA,19886
+wcgw_cli/anthropic_client.py,sha256=Si3u3K3OWe0gNBmwh892QG34yRirUQkhWKXHypg4tZM,19888
 wcgw_cli/cli.py,sha256=-7FBe_lahKyUOhf65iurTA1M1gXXXAiT0OVKQVcZKKo,948
-wcgw_cli/openai_client.py,sha256=GOqoSFazTV-cFjpdZGPM0DIwec8Up2TEcKUbsN40AGY,15990
+wcgw_cli/openai_client.py,sha256=QBRI_LIGI04iBSHZIXv5cGIFaRrPXZLwRgqnDf34uWc,15992
 wcgw_cli/openai_utils.py,sha256=xGOb3W5ALrIozV7oszfGYztpj0FnXdD7jAxm5lEIVKY,2439
-wcgw-5.4.5.dist-info/METADATA,sha256=xyfj7lO9bVE6gJ8EKwkCHMwjkkZMQtRmojieBYyQ6y4,15888
-wcgw-5.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-5.4.5.dist-info/entry_points.txt,sha256=UnjK-MAH4Qssh0tGJDMeij1oi-oRKokItkknP_BwShE,94
-wcgw-5.4.5.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-5.4.5.dist-info/RECORD,,
+wcgw-5.5.1.dist-info/METADATA,sha256=j-jNe7lVsoSLGlT_xsh1Sqq2G4j8GbePY7FmOvsSeoI,16385
+wcgw-5.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-5.5.1.dist-info/entry_points.txt,sha256=UnjK-MAH4Qssh0tGJDMeij1oi-oRKokItkknP_BwShE,94
+wcgw-5.5.1.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-5.5.1.dist-info/RECORD,,

wcgw_cli/anthropic_client.py

@@ -227,7 +227,7 @@ def loop(
             24000,  # coding_max_tokens
             8000,   # noncoding_max_tokens
             mode="wcgw",
-            chat_id="",
+            thread_id="",
         )
 
         if history:

wcgw_cli/openai_client.py

@@ -191,7 +191,7 @@ def loop(
             24000,  # coding_max_tokens
             8000,   # noncoding_max_tokens
             mode="wcgw",
-            chat_id="",
+            thread_id="",
         )
 
         if not history: