wcgw 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

wcgw/client/tools.py

@@ -11,6 +11,7 @@ import threading
 import importlib.metadata
 import time
 import traceback
+from tempfile import TemporaryDirectory
 from typing import (
     Callable,
     Literal,
@@ -24,6 +25,7 @@ from typing import (
 import uuid
 from pydantic import BaseModel, TypeAdapter
 import typer
+from .computer_use import run_computer_tool
 from websockets.sync.client import connect as syncconnect
 
 import os
@@ -57,15 +59,19 @@ from ..types_ import (
     ReadFile,
     ReadImage,
     ResetShell,
+    Mouse,
+    Keyboard,
+    ScreenShot,
+    GetScreenInfo,
 )
 
 from .common import CostData, Models, discard_input
-
+from .sys_utils import command_run
 from .openai_utils import get_input_cost, get_output_cost
 
 console = rich.console.Console(style="magenta", highlight=False, markup=False)
 
-TIMEOUT = 30
+TIMEOUT = 5
 
 
 def render_terminal_output(text: str) -> str:
@@ -107,9 +113,9 @@ def start_shell() -> pexpect.spawn:  # type: ignore
         encoding="utf-8",
         timeout=TIMEOUT,
     )
-    SHELL.expect(PROMPT)
+    SHELL.expect(PROMPT, timeout=TIMEOUT)
     SHELL.sendline("stty -icanon -echo")
-    SHELL.expect(PROMPT)
+    SHELL.expect(PROMPT, timeout=TIMEOUT)
     return SHELL
 
 
@@ -129,15 +135,15 @@ def _get_exit_code() -> int:
         return 0
     # First reset the prompt in case venv was sourced or other reasons.
     SHELL.sendline(f"export PS1={PROMPT}")
-    SHELL.expect(PROMPT)
+    SHELL.expect(PROMPT, timeout=0.2)
     # Reset echo also if it was enabled
     SHELL.sendline("stty -icanon -echo")
-    SHELL.expect(PROMPT)
+    SHELL.expect(PROMPT, timeout=0.2)
     SHELL.sendline("echo $?")
     before = ""
     while not _is_int(before):  # Consume all previous output
         try:
-            SHELL.expect(PROMPT)
+            SHELL.expect(PROMPT, timeout=0.2)
         except pexpect.TIMEOUT:
             print(f"Couldn't get exit code, before: {before}")
             raise
@@ -153,6 +159,7 @@ def _get_exit_code() -> int:
 
 BASH_CLF_OUTPUT = Literal["repl", "pending"]
 BASH_STATE: BASH_CLF_OUTPUT = "repl"
+IS_IN_DOCKER: Optional[str] = ""
 CWD = os.getcwd()
 
 
@@ -167,10 +174,11 @@ Current working directory: {CWD}
 
 
 def reset_shell() -> str:
-    global SHELL, BASH_STATE, CWD
+    global SHELL, BASH_STATE, CWD, IS_IN_DOCKER
     SHELL.close(True)
     SHELL = start_shell()
     BASH_STATE = "repl"
+    IS_IN_DOCKER = ""
     CWD = os.getcwd()
     return "Reset successful" + get_status()
 
@@ -207,7 +215,7 @@ def update_repl_prompt(command: str) -> bool:
 
 def get_cwd() -> str:
     SHELL.sendline("pwd")
-    SHELL.expect(PROMPT)
+    SHELL.expect(PROMPT, timeout=0.2)
     assert isinstance(SHELL.before, str)
     current_dir = render_terminal_output(SHELL.before).strip()
     return current_dir
@@ -234,6 +242,7 @@ def execute_bash(
     enc: tiktoken.Encoding,
     bash_arg: BashCommand | BashInteraction,
     max_tokens: Optional[int],
+    timeout_s: Optional[float],
 ) -> tuple[str, float]:
     global SHELL, BASH_STATE, CWD
     try:
@@ -333,13 +342,13 @@ def execute_bash(
         SHELL.expect(PROMPT)
         return "---\n\nFailure: user interrupted the execution", 0.0
 
-    wait = 5
+    wait = timeout_s or TIMEOUT
     index = SHELL.expect([PROMPT, pexpect.TIMEOUT], timeout=wait)
     if index == 1:
         BASH_STATE = "pending"
         text = SHELL.before or ""
 
-        text = render_terminal_output(text)
+        text = render_terminal_output(text[-100_000:])
         tokens = enc.encode(text)
 
         if max_tokens and len(tokens) >= max_tokens:
@@ -438,14 +447,26 @@ def read_image_from_shell(file_path: str) -> ImageData:
     if not os.path.isabs(file_path):
         file_path = os.path.join(CWD, file_path)
 
-    if not os.path.exists(file_path):
-        raise ValueError(f"File {file_path} does not exist")
+    if not IS_IN_DOCKER:
+        if not os.path.exists(file_path):
+            raise ValueError(f"File {file_path} does not exist")
 
-    with open(file_path, "rb") as image_file:
-        image_bytes = image_file.read()
-        image_b64 = base64.b64encode(image_bytes).decode("utf-8")
-        image_type = mimetypes.guess_type(file_path)[0]
-        return ImageData(media_type=image_type, data=image_b64)  # type: ignore
+        with open(file_path, "rb") as image_file:
+            image_bytes = image_file.read()
+            image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+            image_type = mimetypes.guess_type(file_path)[0]
+            return ImageData(media_type=image_type, data=image_b64)  # type: ignore
+    else:
+        with TemporaryDirectory() as tmpdir:
+            rcode = os.system(f"docker cp {IS_IN_DOCKER}:{file_path} {tmpdir}")
+            if rcode != 0:
+                raise Exception(f"Error: Read failed with code {rcode}")
+            path_ = os.path.join(tmpdir, os.path.basename(file_path))
+            with open(path_, "rb") as f:
+                image_bytes = f.read()
+            image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+            image_type = mimetypes.guess_type(file_path)[0]
+            return ImageData(media_type=image_type, data=image_b64)  # type: ignore
 
 
 def write_file(writefile: CreateFileNew, error_on_exist: bool) -> str:
@@ -454,19 +475,42 @@ def write_file(writefile: CreateFileNew, error_on_exist: bool) -> str:
     else:
         path_ = writefile.file_path
 
-    if error_on_exist and os.path.exists(path_):
-        file_data = Path(path_).read_text()
-        if file_data:
-            return f"Error: can't write to existing file {path_}, use other functions to edit the file"
+    if not IS_IN_DOCKER:
+        if error_on_exist and os.path.exists(path_):
+            file_data = Path(path_).read_text()
+            if file_data:
+                return f"Error: can't write to existing file {path_}, use other functions to edit the file"
 
-    path = Path(path_)
-    path.parent.mkdir(parents=True, exist_ok=True)
+        path = Path(path_)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with path.open("w") as f:
+                f.write(writefile.file_content)
+        except OSError as e:
+            return f"Error: {e}"
+    else:
+        if error_on_exist:
+            # Check if it exists using os.system
+            cmd = f"test -f {path_}"
+            status = os.system(f'docker exec {IS_IN_DOCKER} bash -c "{cmd}"')
+            if status == 0:
+                return f"Error: can't write to existing file {path_}, use other functions to edit the file"
+
+        with TemporaryDirectory() as tmpdir:
+            tmppath = os.path.join(tmpdir, os.path.basename(path_))
+            with open(tmppath, "w") as f:
+                f.write(writefile.file_content)
+            os.chmod(tmppath, 0o777)
+            parent_dir = os.path.dirname(path_)
+            rcode = os.system(f"docker exec {IS_IN_DOCKER} mkdir -p {parent_dir}")
+            if rcode != 0:
+                return f"Error: Write failed with code while creating dirs {rcode}"
+
+            rcode = os.system(f"docker cp {tmppath} {IS_IN_DOCKER}:{path_}")
+            if rcode != 0:
+                return f"Error: Write failed with code {rcode}"
 
-    try:
-        with path.open("w") as f:
-            f.write(writefile.file_content)
-    except OSError as e:
-        return f"Error: {e}"
     console.print(f"File written to {path_}")
     return "Success"
 
@@ -545,11 +589,21 @@ def do_diff_edit(fedit: FileEdit) -> str:
     else:
         path_ = fedit.file_path
 
-    if not os.path.exists(path_):
-        raise Exception(f"Error: file {path_} does not exist")
+    if not IS_IN_DOCKER:
+        if not os.path.exists(path_):
+            raise Exception(f"Error: file {path_} does not exist")
 
-    with open(path_) as f:
-        apply_diff_to = f.read()
+        with open(path_) as f:
+            apply_diff_to = f.read()
+    else:
+        # Copy from docker
+        with TemporaryDirectory() as tmpdir:
+            rcode = os.system(f"docker cp {IS_IN_DOCKER}:{path_} {tmpdir}")
+            if rcode != 0:
+                raise Exception(f"Error: Read failed with code {rcode}")
+            path_tmp = os.path.join(tmpdir, os.path.basename(path_))
+            with open(path_tmp, "r") as f:
+                apply_diff_to = f.read()
 
     fedit.file_edit_using_search_replace_blocks = (
         fedit.file_edit_using_search_replace_blocks.strip()
@@ -597,40 +651,20 @@ def do_diff_edit(fedit: FileEdit) -> str:
             "Error: no valid search-replace blocks found, please check your syntax for FileEdit"
         )
 
-    with open(path_, "w") as f:
-        f.write(apply_diff_to)
-
-    return "Success"
-
-
-def file_edit(fedit: FileEditFindReplace) -> str:
-    if not os.path.isabs(fedit.file_path):
-        raise Exception(
-            f"Failure: file_path should be absolute path, current working directory is {CWD}"
-        )
+    if not IS_IN_DOCKER:
+        with open(path_, "w") as f:
+            f.write(apply_diff_to)
     else:
-        path_ = fedit.file_path
+        with TemporaryDirectory() as tmpdir:
+            path_tmp = os.path.join(tmpdir, os.path.basename(path_))
+            with open(path_tmp, "w") as f:
+                f.write(apply_diff_to)
+            os.chmod(path_tmp, 0o777)
+            # Copy to docker using docker cp
+            rcode = os.system(f"docker cp {path_tmp} {IS_IN_DOCKER}:{path_}")
+            if rcode != 0:
+                raise Exception(f"Error: Write failed with code {rcode}")
 
-    if not os.path.exists(path_):
-        raise Exception(f"Error: file {path_} does not exist")
-
-    if not fedit.find_lines:
-        raise Exception("Error: `find_lines` cannot be empty")
-
-    out_string = "\n".join("> " + line for line in fedit.find_lines.split("\n"))
-    in_string = "\n".join("< " + line for line in fedit.replace_with_lines.split("\n"))
-    console.log(f"Editing file: {path_}\n---\n{out_string}\n---\n{in_string}\n---")
-    try:
-        with open(path_) as f:
-            content = f.read()
-
-        content = edit_content(content, fedit.find_lines, fedit.replace_with_lines)
-
-        with open(path_, "w") as f:
-            f.write(content)
-    except OSError as e:
-        raise Exception(f"Error: {e}")
-    console.print(f"File written to {path_}")
     return "Success"
 
 
@@ -669,6 +703,10 @@ TOOLS = (
     | ReadImage
     | ReadFile
     | Initialize
+    | Mouse
+    | Keyboard
+    | ScreenShot
+    | GetScreenInfo
 )
 
 
@@ -702,6 +740,14 @@ def which_tool_name(name: str) -> Type[TOOLS]:
         return ReadFile
     elif name == "Initialize":
         return Initialize
+    elif name == "Mouse":
+        return Mouse
+    elif name == "Keyboard":
+        return Keyboard
+    elif name == "ScreenShot":
+        return ScreenShot
+    elif name == "GetScreenInfo":
+        return GetScreenInfo
     else:
         raise ValueError(f"Unknown tool name: {name}")
 
@@ -719,12 +765,17 @@ def get_tool_output(
     | DoneFlag
     | ReadImage
     | Initialize
-    | ReadFile,
+    | ReadFile
+    | Mouse
+    | Keyboard
+    | ScreenShot
+    | GetScreenInfo,
     enc: tiktoken.Encoding,
     limit: float,
     loop_call: Callable[[str, float], tuple[str, float]],
     max_tokens: Optional[int],
-) -> tuple[str | ImageData | DoneFlag, float]:
+) -> tuple[list[str | ImageData | DoneFlag], float]:
+    global IS_IN_DOCKER
     if isinstance(args, dict):
         adapter = TypeAdapter[
             Confirmation
@@ -739,6 +790,10 @@ def get_tool_output(
             | ReadImage
             | ReadFile
             | Initialize
+            | Mouse
+            | Keyboard
+            | ScreenShot
+            | GetScreenInfo,
         ](
             Confirmation
             | BashCommand
@@ -752,6 +807,10 @@ def get_tool_output(
             | ReadImage
             | ReadFile
             | Initialize
+            | Mouse
+            | Keyboard
+            | ScreenShot
+            | GetScreenInfo
         )
         arg = adapter.validate_python(args)
     else:
@@ -762,13 +821,10 @@ def get_tool_output(
         output = ask_confirmation(arg), 0.0
     elif isinstance(arg, (BashCommand | BashInteraction)):
         console.print("Calling execute bash tool")
-        output = execute_bash(enc, arg, max_tokens)
+        output = execute_bash(enc, arg, max_tokens, None)
     elif isinstance(arg, CreateFileNew):
         console.print("Calling write file tool")
         output = write_file(arg, True), 0
-    elif isinstance(arg, FileEditFindReplace):
-        console.print("Calling file edit tool")
-        output = file_edit(arg), 0.0
     elif isinstance(arg, FileEdit):
         console.print("Calling full file edit tool")
         output = do_diff_edit(arg), 0.0
@@ -790,11 +846,50 @@ def get_tool_output(
     elif isinstance(arg, Initialize):
         console.print("Calling initial info tool")
         output = initial_info(), 0.0
+    elif isinstance(arg, (Mouse, Keyboard, ScreenShot, GetScreenInfo)):
+        console.print(f"Calling {type(arg).__name__} tool")
+        outputs_cost = run_computer_tool(arg), 0.0
+        console.print(outputs_cost[0][0])
+        outputs: list[ImageData | str | DoneFlag] = [outputs_cost[0][0]]
+        imgBs64 = outputs_cost[0][1]
+        if imgBs64:
+            console.print("Captured screenshot")
+            outputs.append(ImageData(media_type="image/png", data=imgBs64))
+            if not IS_IN_DOCKER and isinstance(arg, GetScreenInfo):
+                try:
+                    # At this point we should go into the docker env
+                    res, _ = execute_bash(
+                        enc,
+                        BashCommand(
+                            command=f"docker exec -it {arg.docker_image_id} sh"
+                        ),
+                        None,
+                        0.2,
+                    )
+                    # At this point we should go into the docker env
+                    res, _ = execute_bash(
+                        enc,
+                        BashInteraction(
+                            send_text=f"export PS1={PROMPT}", type="BashInteraction"
+                        ),
+                        None,
+                        0.2,
+                    )
+                    # Do chown of home dir
+                except Exception as e:
+                    reset_shell()
+                    raise Exception(
+                        f"Some error happened while going inside docker. I've reset the shell. Please start again. Error {e}"
+                    )
+                IS_IN_DOCKER = arg.docker_image_id
+        return outputs, outputs_cost[1]
     else:
         raise ValueError(f"Unknown tool: {arg}")
-
-    console.print(str(output[0]))
-    return output
+    if isinstance(output[0], str):
+        console.print(str(output[0]))
+    else:
+        console.print(f"Received {type(output[0])} from tool")
+    return [output[0]], output[1]
 
 
 History = list[ChatCompletionMessageParam]
@@ -843,9 +938,10 @@ def register_client(server_url: str, client_uuid: str = "") -> None:
                 if isinstance(mdata.data, str):
                     raise Exception(mdata)
                 try:
-                    output, cost = get_tool_output(
+                    outputs, cost = get_tool_output(
                         mdata.data, default_enc, 0.0, lambda x, y: ("", 0), 8000
                     )
+                    output = outputs[0]
                     curr_cost += cost
                     print(f"{curr_cost=}")
                 except Exception as e:
@@ -883,12 +979,22 @@ def read_file(readfile: ReadFile, max_tokens: Optional[int]) -> str:
     if not os.path.isabs(readfile.file_path):
         return f"Failure: file_path should be absolute path, current working directory is {CWD}"
 
-    path = Path(readfile.file_path)
-    if not path.exists():
-        return f"Error: file {readfile.file_path} does not exist"
+    if not IS_IN_DOCKER:
+        path = Path(readfile.file_path)
+        if not path.exists():
+            return f"Error: file {readfile.file_path} does not exist"
 
-    with path.open("r") as f:
-        content = f.read()
+        with path.open("r") as f:
+            content = f.read()
+
+    else:
+        return_code, content, stderr = command_run(
+            f"cat {readfile.file_path}", timeout=TIMEOUT
+        )
+        if return_code != 0:
+            raise Exception(
+                f"Error: cat {readfile.file_path} failed with code {return_code}\nstdout: {content}\nstderr: {stderr}"
+            )
 
     if max_tokens is not None:
         tokens = default_enc.encode(content)

wcgw/types_.py

@@ -51,3 +51,44 @@ class FileEdit(BaseModel):
 
 class Initialize(BaseModel):
     type: Literal["Initialize"]
+
+
+class GetScreenInfo(BaseModel):
+    type: Literal["GetScreenInfo"]
+    docker_image_id: str
+
+
+class ScreenShot(BaseModel):
+    type: Literal["ScreenShot"]
+    docker_image_id: str
+
+
+class MouseMove(BaseModel):
+    x: int
+    y: int
+    type: Literal["MouseMove"]
+
+
+class LeftClickDrag(BaseModel):
+    x: int
+    y: int
+
+
+class MouseButton(BaseModel):
+    button_type: Literal[
+        "left_click",
+        "right_click",
+        "middle_click",
+        "double_click",
+        "scroll_up",
+        "scroll_down",
+    ]
+
+
+class Mouse(BaseModel):
+    action: MouseButton | LeftClickDrag | MouseMove
+
+
+class Keyboard(BaseModel):
+    action: Literal["key", "type"]
+    text: str

{wcgw-1.4.0.dist-info → wcgw-1.5.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: wcgw
-Version: 1.4.0
+Version: 1.5.1
 Summary: What could go wrong giving full shell access to chatgpt?
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
-Requires-Python: <3.13,>=3.10
+Requires-Python: <3.13,>=3.11
 Requires-Dist: anthropic>=0.39.0
 Requires-Dist: fastapi>=0.115.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp
 Requires-Dist: mypy>=1.11.2
 Requires-Dist: nltk>=3.9.1
 Requires-Dist: openai>=1.46.0
@@ -27,82 +27,124 @@ Requires-Dist: uvicorn>=0.31.0
 Requires-Dist: websockets>=13.1
 Description-Content-Type: text/markdown
 
-# Enable shell access on chatgpt.com
-A custom gpt on chatgpt web app to interact with your local shell.
+# Shell and Coding agent on Chatgpt and Claude desktop apps
+
+A custom gpt on chatgpt web/desktop apps to interact with your local shell, edit files, run code, etc.
 
 [![Tests](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml/badge.svg?branch=main)](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml)
 [![Build](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml/badge.svg)](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml)
 
+[New feature] [26-Nov-2024] Claude desktop support for shell, computer-control, coding agent.
+[src/wcgw/client/mcp_server/Readme.md](src/wcgw/client/mcp_server/Readme.md)
+
 ### 🚀 Highlights
+
 - ⚡ **Full Shell Access**: No restrictions, complete control.
 - ⚡ **Create, Execute, Iterate**: Ask the gpt to keep running compiler checks till all errors are fixed, or ask it to keep checking for the status of a long running command till it's done.
-- ⚡ **Interactive Command Handling**: Supports interactive commands using arrow keys, interrupt, and ansi escape sequences. 
+- ⚡ **Interactive Command Handling**: Supports interactive commands using arrow keys, interrupt, and ansi escape sequences.
 - ⚡ **REPL support**: [beta] Supports python/node and other REPL execution.
 
-###  🪜 Steps: 
+## Claude
+Full readme [src/wcgw/client/mcp_server/Readme.md](src/wcgw/client/mcp_server/Readme.md)
+### Setup
+
+Update `claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "wcgw": {
+      "command": "uvx",
+      "args": ["--from", "wcgw@latest", "wcgw_mcp"]
+    }
+  }
+}
+```
+
+Then restart claude app.
+You can then ask claude to execute shell commands, read files, edit files, run your code, etc.
+
+## ChatGPT
+
+### 🪜 Steps:
+
 1. Run the [cli client](https://github.com/rusiaaman/wcgw?tab=readme-ov-file#client) in any directory of choice.
 2. Share the generated id with this GPT: `https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access`
 3. The custom GPT can now run any command on your cli
 
+### Client
 
-## Client
 You need to keep running this client for GPT to access your shell. Run it in a version controlled project's root.
 
-### Option 1: using uv [Recommended]
+#### Option 1: using uv [Recommended]
+
 ```sh
 $ curl -LsSf https://astral.sh/uv/install.sh | sh
 $ uvx wcgw@latest
 ```
 
-### Option 2: using pip
+#### Option 2: using pip
+
 Supports python >=3.10 and <3.13
+
 ```sh
 $ pip3 install wcgw
 $ wcgw
 ```
 
-
 This will print a UUID that you need to share with the gpt.
 
+### Chat
 
-## Chat
 Open the following link or search the "wcgw" custom gpt using "Explore GPTs" on chatgpt.com
 
 https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access
 
 Finally, let the chatgpt know your user id in any format. E.g., "user_id=<your uuid>" followed by rest of your instructions.
 
-NOTE: you can resume a broken connection 
+NOTE: you can resume a broken connection
 `wcgw --client-uuid $previous_uuid`
 
-# How it works
+### How it works on chatgpt app?
+
 Your commands are relayed through a server to the terminal client. [You could host the server on your own](https://github.com/rusiaaman/wcgw?tab=readme-ov-file#creating-your-own-custom-gpt-and-the-relay-server). For public convenience I've hosted one at https://wcgw.arcfu.com thanks to the gcloud free tier plan.
 
 Chatgpt sends a request to the relay server using the user id that you share with it. The relay server holds a websocket with the terminal client against the user id and acts as a proxy to pass the request.
 
-It's secure in both the directions. Either a malicious actor or a malicious Chatgpt has to correctly guess your UUID for any security breach. 
+It's secure in both the directions. Either a malicious actor or a malicious Chatgpt has to correctly guess your UUID for any security breach.
 
 # Showcase
 
-## Unit tests and github actions
+## Claude desktop
+
+### Resize image and move it to a new dir
+
+![example](https://github.com/rusiaaman/wcgw/blob/main/static/example.jpg?raw=true)
+
+## Chatgpt app
+
+### Unit tests and github actions
+
 [The first version of unit tests and github workflow to test on multiple python versions were written by the custom chatgpt](https://chatgpt.com/share/6717f922-8998-8005-b825-45d4b348b4dd)
 
-## Create a todo app using react + typescript + vite
-![Screenshot](https://github.com/rusiaaman/wcgw/blob/main/static/ss1.png?raw=true)
+### Create a todo app using react + typescript + vite
 
+![Screenshot](https://github.com/rusiaaman/wcgw/blob/main/static/ss1.png?raw=true)
 
 # Privacy
+
 The relay server doesn't store any data. I can't access any information passing through it and only secure channels are used to communicate.
 
 You may host the server on your own and create a custom gpt using the following section.
 
 # Creating your own custom gpt and the relay server.
+
 I've used the following instructions and action json schema to create the custom GPT. (Replace wcgw.arcfu.com with the address to your server)
 
 https://github.com/rusiaaman/wcgw/blob/main/gpt_instructions.txt
 https://github.com/rusiaaman/wcgw/blob/main/gpt_action_json_schema.json
 
-Run the server 
+Run the server
 `gunicorn --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:443 src.wcgw.relay.serve:app  --certfile fullchain.pem  --keyfile  privkey.pem`
 
 If you don't have public ip and domain name, you can use `ngrok` or similar services to get a https address to the api.
@@ -110,19 +152,24 @@ If you don't have public ip and domain name, you can use `ngrok` or similar serv
 The specify the server url in the `wcgw` command like so
 `wcgw --server-url https://your-url/v1/register`
 
-# Claude Support
-WCGW now supports Claude Desktop through the MCP protocol, allowing you to use Claude's capabilities directly from your desktop environment. This integration enables seamless interaction between Claude and your local shell.
+# [Optional] Local shell access with openai API key or anthropic API key
 
-# [Optional] Local shell access with openai API key
+## Openai
 
 Add `OPENAI_API_KEY` and `OPENAI_ORG_ID` env variables.
 
-Clone the repo and run to install `wcgw_local` command
+Then run
+
+`uvx --from wcgw@latest wcgw_local  --limit 0.1` # Cost limit $0.1
+
+You can now directly write messages or press enter key to open vim for multiline message and text pasting.
+
+## Anthropic
 
-`pip install .`
+Add `ANTHROPIC_API_KEY` env variable.
 
-Then run 
+Then run
 
-`wcgw_local  --limit 0.1` # Cost limit $0.1 
+`uvx --from wcgw@latest wcgw_local --claude`
 
 You can now directly write messages or press enter key to open vim for multiline message and text pasting.