wcgw 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

wcgw/basic.py

@@ -1,4 +1,6 @@
+import base64
 import json
+import mimetypes
 from pathlib import Path
 import sys
 import traceback
@@ -8,17 +10,21 @@ from openai import OpenAI
 from openai.types.chat import (
     ChatCompletionMessageParam,
     ChatCompletionAssistantMessageParam,
+    ChatCompletionUserMessageParam,
+    ChatCompletionContentPartParam,
     ChatCompletionMessage,
     ParsedChatCompletionMessage,
 )
 import rich
+import petname
 from typer import Typer
 import uuid
 
-from .common import Models, discard_input
-from .common import CostData, History
+from wcgw.common import Config, text_from_editor
+
+from .common import Models
 from .openai_utils import get_input_cost, get_output_cost
-from .tools import ExecuteBash, GetShellOutputLastCommand
+from .tools import ExecuteBash, ReadImage, ImageData
 
 from .tools import (
     BASH_CLF_OUTPUT,
@@ -34,40 +40,14 @@ from .tools import (
 import tiktoken
 
 from urllib import parse
-import subprocess
 import os
-import tempfile
 
 import toml
-from pydantic import BaseModel
 
 
 from dotenv import load_dotenv
 
-
-class Config(BaseModel):
-    model: Models
-    secondary_model: Models
-    cost_limit: float
-    cost_file: dict[Models, CostData]
-    cost_unit: str = "$"
-
-
-def text_from_editor(console: rich.console.Console) -> str:
-    # First consume all the input till now
-    discard_input()
-    console.print("\n---------------------------------------\n# User message")
-    data = input()
-    if data:
-        return data
-    editor = os.environ.get("EDITOR", "vim")
-    with tempfile.NamedTemporaryFile(suffix=".tmp") as tf:
-        subprocess.run([editor, tf.name], check=True)
-        with open(tf.name, "r") as f:
-            data = f.read()
-            console.print(data)
-            return data
-
+History = list[ChatCompletionMessageParam]
 
 def save_history(history: History, session_id: str) -> None:
     myid = str(history[1]["content"]).replace("/", "_").replace(" ", "_").lower()[:60]
@@ -80,6 +60,38 @@ def save_history(history: History, session_id: str) -> None:
         json.dump(history, f, indent=3)
 
 
+def parse_user_message_special(msg: str) -> ChatCompletionUserMessageParam:
+    # Search for lines starting with `%` and treat them as special commands
+    parts: list[ChatCompletionContentPartParam] = []
+    for line in msg.split("\n"):
+        if line.startswith("%"):
+            args = line[1:].strip().split(" ")
+            command = args[0]
+            assert command == 'image'
+            image_path = args[1]
+            with open(image_path, 'rb') as f:
+                image_bytes = f.read()
+                image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+                image_type = mimetypes.guess_type(image_path)[0]
+                dataurl=f'data:{image_type};base64,{image_b64}'
+            parts.append({
+                'type': 'image_url',
+                'image_url': {
+                    'url': dataurl,
+                    'detail': 'auto'
+                }
+            })
+        else:
+            if len(parts) > 0 and parts[-1]['type'] == 'text':
+                parts[-1]['text'] += '\n' + line
+            else:
+                parts.append({'type': 'text', 'text': line})
+    return {
+        'role': 'user',
+        'content': parts
+    }
+
+
 app = Typer(pretty_exceptions_show_locals=False)
 
 
@@ -94,6 +106,7 @@ def loop(
     session_id = str(uuid.uuid4())[:6]
 
     history: History = []
+    waiting_for_assistant = False
     if resume:
         if resume == "latest":
             resume_path = sorted(Path(".wcgw").iterdir(), key=os.path.getmtime)[-1]
@@ -108,6 +121,7 @@ def loop(
         if history[1]["role"] != "user":
             raise ValueError("Invalid history file, second message should be user")
         first_message = ""
+        waiting_for_assistant = history[-1]['role'] != 'assistant'
 
     my_dir = os.path.dirname(__file__)
     config_file = os.path.join(my_dir, "..", "..", "config.toml")
@@ -134,19 +148,18 @@ Execute a bash script. Stateful (beware with subsequent calls).
 Execute commands using `execute_command` attribute.
 Do not use interactive commands like nano. Prefer writing simpler commands.
 Last line will always be `(exit <int code>)` except if
-the last line is `(waiting for input)` which will be the case if you've run any interactive command (which you shouldn't run) by mistake. You can then send input using `send_ascii` attributes.
+the last line is `(pending)` if the program is still running or waiting for user inputs. You can then send input using `send_ascii` attributes. You get status by sending `send_ascii: [10]`.
 Optionally the last line is `(won't exit)` in which case you need to kill the process if you want to run a new command.
 Optionally `exit shell has restarted` is the output, in which case environment resets, you can run fresh commands.
 The first line might be `(...truncated)` if the output is too long.""",
         ),
-        openai.pydantic_function_tool(
-            GetShellOutputLastCommand,
-            description="Get output of the last command run in the shell. Use this in case you want to know status of a running program.",
-        ),
         openai.pydantic_function_tool(
             Writefile,
             description="Write content to a file. Provide file path and content. Use this instead of ExecuteBash for writing files.",
         ),
+        openai.pydantic_function_tool(
+            ReadImage, description="Read an image from the shell."
+        ),
     ]
     uname_sysname = os.uname().sysname
     uname_machine = os.uname().machine
@@ -165,12 +178,11 @@ System information:
     - Machine: {uname_machine}
 """
 
-    has_tool_output = False
     if not history:
         history = [{"role": "system", "content": system}]
     else:
         if history[-1]["role"] == "tool":
-            has_tool_output = True
+            waiting_for_assistant = True
 
     client = OpenAI()
 
@@ -189,16 +201,16 @@ System information:
             )
             break
 
-        if not has_tool_output:
+        if not waiting_for_assistant:
             if first_message:
                 msg = first_message
                 first_message = ""
             else:
                 msg = text_from_editor(user_console)
 
-            history.append({"role": "user", "content": msg})
+            history.append(parse_user_message_special(msg))
         else:
-            has_tool_output = False
+            waiting_for_assistant = False
 
         cost_, input_toks_ = get_input_cost(
             config.cost_file[config.model], enc, history
@@ -223,6 +235,7 @@ System information:
         _histories: History = []
         item: ChatCompletionMessageParam
         full_response: str = ""
+        image_histories: History = []
         try:
             for chunk in stream:
                 if chunk.choices[0].finish_reason == "tool_calls":
@@ -236,7 +249,7 @@ System information:
                                 "type": "function",
                                 "function": {
                                     "arguments": tool_args,
-                                    "name": "execute_bash",
+                                    "name": type(which_tool(tool_args)).__name__,
                                 },
                             }
                             for tool_call_id, toolcallargs in tool_call_args_by_id.items()
@@ -252,7 +265,7 @@ System information:
                     )
                     system_console.print(f"\nTotal cost: {config.cost_unit}{cost:.3f}")
                     output_toks += output_toks_
-
+                    
                     _histories.append(item)
                     for tool_call_id, toolcallargs in tool_call_args_by_id.items():
                         for toolindex, tool_args in toolcallargs.items():
@@ -284,13 +297,50 @@ System information:
                                     f"\nTotal cost: {config.cost_unit}{cost:.3f}"
                                 )
                                 return output_or_done.task_output, cost
+                                
                             output = output_or_done
 
-                            item = {
-                                "role": "tool",
-                                "content": str(output),
-                                "tool_call_id": tool_call_id + str(toolindex),
-                            }
+                            if isinstance(output, ImageData):
+                                randomId = petname.Generate(2, "-")
+                                if not image_histories:
+                                    image_histories.extend([
+                                        {
+                                            'role': 'assistant',
+                                            'content': f'Share images with ids: {randomId}'
+
+                                        },
+                                        {
+                                            'role': 'user',
+                                            'content': [{
+                                                'type': 'image_url',
+                                                'image_url': {
+                                                    'url': output.dataurl,
+                                                    'detail': 'auto'
+                                                }
+                                            }]
+                                        }]
+                                    )
+                                else:
+                                    image_histories[0]['content'] += ', ' + randomId
+                                    image_histories[1]["content"].append({ # type: ignore
+                                        'type': 'image_url',
+                                        'image_url': {
+                                            'url': output.dataurl,
+                                            'detail': 'auto'
+                                        }
+                                    })
+
+                                item = {
+                                    "role": "tool",
+                                    "content": f'Ask user for image id: {randomId}',
+                                    "tool_call_id": tool_call_id + str(toolindex),
+                                }
+                            else:
+                                item = {
+                                    "role": "tool",
+                                    "content": str(output),
+                                    "tool_call_id": tool_call_id + str(toolindex),
+                                }
                             cost_, output_toks_ = get_output_cost(
                                 config.cost_file[config.model], enc, item
                             )
@@ -298,7 +348,7 @@ System information:
                             output_toks += output_toks_
 
                             _histories.append(item)
-                    has_tool_output = True
+                    waiting_for_assistant = True
                     break
                 elif chunk.choices[0].finish_reason:
                     assistant_console.print("")
@@ -327,11 +377,11 @@ System information:
                 assistant_console.print(chunk_str, end="")
                 full_response += chunk_str
         except KeyboardInterrupt:
-            has_tool_output = False
+            waiting_for_assistant = False
             input("Interrupted...enter to redo the current turn")
         else:
             history.extend(_histories)
-
+            history.extend(image_histories)
             save_history(history, session_id)
 
     return "Couldn't finish the task", cost

wcgw/common.py

@@ -1,9 +1,13 @@
+import os
 import select
+import subprocess
 import sys
+import tempfile
 import termios
 import tty
 from typing import Literal
 from pydantic import BaseModel
+import rich
 
 
 class CostData(BaseModel):
@@ -11,14 +15,6 @@ class CostData(BaseModel):
     cost_per_1m_output_tokens: float
 
 
-from openai.types.chat import (
-    ChatCompletionMessageParam,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessage,
-    ParsedChatCompletionMessage,
-)
-
-History = list[ChatCompletionMessageParam]
 Models = Literal["gpt-4o-2024-08-06", "gpt-4o-mini"]
 
 
@@ -45,3 +41,27 @@ def discard_input() -> None:
     finally:
         # Restore old terminal settings
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+class Config(BaseModel):
+    model: Models
+    secondary_model: Models
+    cost_limit: float
+    cost_file: dict[Models, CostData]
+    cost_unit: str = "$"
+
+
+def text_from_editor(console: rich.console.Console) -> str:
+    # First consume all the input till now
+    discard_input()
+    console.print("\n---------------------------------------\n# User message")
+    data = input()
+    if data:
+        return data
+    editor = os.environ.get("EDITOR", "vim")
+    with tempfile.NamedTemporaryFile(suffix=".tmp") as tf:
+        subprocess.run([editor, tf.name], check=True)
+        with open(tf.name, "r") as f:
+            data = f.read()
+            console.print(data)
+            return data

wcgw/openai_utils.py

@@ -28,9 +28,19 @@ def get_input_cost(
     input_tokens = 0
     for msg in history:
         content = msg["content"]
-        if not isinstance(content, str):
+        refusal = msg.get("refusal")
+        if isinstance(content, list):
+            for part in content:
+                if 'text' in part:
+                    input_tokens += len(enc.encode(part['text']))
+        elif content is None:
+            if refusal is None:
+                raise ValueError("Expected content or refusal to be present")
+            input_tokens += len(enc.encode(str(refusal)))
+        elif not isinstance(content, str):
             raise ValueError(f"Expected content to be string, got {type(content)}")
-        input_tokens += len(enc.encode(content))
+        else:
+            input_tokens += len(enc.encode(content))
     cost = input_tokens * cost_map.cost_per_1m_input_tokens / 1_000_000
     return cost, input_tokens
 

wcgw/tools.py

@@ -1,11 +1,14 @@
 import asyncio
+import base64
 import json
+import mimetypes
 import sys
 import threading
 import traceback
-from typing import Callable, Literal, Optional, ParamSpec, Sequence, TypeVar, TypedDict
+from typing import Callable, Literal, NewType, Optional, ParamSpec, Sequence, TypeVar, TypedDict
 import uuid
 from pydantic import BaseModel, TypeAdapter
+from websockets.sync.client import connect as syncconnect
 
 import os
 import tiktoken
@@ -67,7 +70,7 @@ class Writefile(BaseModel):
 
 def start_shell():
     SHELL = pexpect.spawn(
-        "/bin/bash",
+        "/bin/bash --noprofile --norc",
         env={**os.environ, **{"PS1": "#@@"}},
         echo=False,
         encoding="utf-8",
@@ -82,11 +85,26 @@ def start_shell():
 SHELL = start_shell()
 
 
+def _is_int(mystr: str) -> bool:
+    try:
+        int(mystr)
+        return True
+    except ValueError:
+        return False
+
+
 def _get_exit_code() -> int:
     SHELL.sendline("echo $?")
-    SHELL.expect("#@@")
-    assert isinstance(SHELL.before, str)
-    return int((SHELL.before))
+    before = ""
+    while not _is_int(before):  # Consume all previous output
+        SHELL.expect("#@@")
+        assert isinstance(SHELL.before, str)
+        before = SHELL.before
+
+    try:
+        return int((before))
+    except ValueError:
+        raise ValueError(f"Malformed output: {before}")
 
 
 Specials = Literal["Key-up", "Key-down", "Key-left", "Key-right", "Enter", "Ctrl-c"]
@@ -97,10 +115,6 @@ class ExecuteBash(BaseModel):
     send_ascii: Optional[Sequence[int | Specials]] = None
 
 
-class GetShellOutputLastCommand(BaseModel):
-    type: Literal["get_output_of_last_command"] = "get_output_of_last_command"
-
-
 BASH_CLF_OUTPUT = Literal["running", "waiting_for_input", "wont_exit"]
 BASH_STATE: BASH_CLF_OUTPUT = "running"
 
@@ -116,9 +130,9 @@ def get_output_of_last_command(enc: tiktoken.Encoding) -> str:
     return output
 
 
-WETTING_INPUT_MESSAGE = """A command is already running waiting for input. NOTE: You can't run multiple shell sessions, likely a previous program hasn't exited. 
-1. Get its output using `GetShellOutputLastCommand` OR
-2. Use  `send_ascii` to give inputs to the running program, don't use `execute_command` OR
+WAITING_INPUT_MESSAGE = """A command is already running waiting for input. NOTE: You can't run multiple shell sessions, likely a previous program hasn't exited. 
+1. Get its output using `send_ascii: [10]`
+2. Use `send_ascii` to give inputs to the running program, don't use `execute_command` OR
 3. kill the previous program by sending ctrl+c first using `send_ascii`"""
 
 
@@ -131,7 +145,7 @@ def execute_bash(
     try:
         if bash_arg.execute_command:
             if BASH_STATE == "waiting_for_input":
-                raise ValueError(WETTING_INPUT_MESSAGE)
+                raise ValueError(WAITING_INPUT_MESSAGE)
             elif BASH_STATE == "wont_exit":
                 raise ValueError(
                     """A command is already running that hasn't exited. NOTE: You can't run multiple shell sessions, likely a previous program is in infinite loop.
@@ -192,9 +206,7 @@ def execute_bash(
                 text = "...(truncated)\n" + enc.decode(tokens[-2047:])
 
             last_line = (
-                "(waiting for input)"
-                if BASH_STATE == "waiting_for_input"
-                else "(won't exit)"
+                "(pending)" if BASH_STATE == "waiting_for_input" else "(won't exit)"
             )
             return text + f"\n{last_line}", cost
         index = SHELL.expect(["#@@", pexpect.TIMEOUT], timeout=wait)
@@ -211,7 +223,9 @@ def execute_bash(
         exit_code = _get_exit_code()
         output += f"\n(exit {exit_code})"
 
-    except ValueError:
+    except ValueError as e:
+        console.print(output)
+        traceback.print_exc()
         console.print("Malformed output, restarting shell", style="red")
         # Malformed output, restart shell
         SHELL.close(True)
@@ -220,6 +234,35 @@ def execute_bash(
     return output, 0
 
 
+class ReadImage(BaseModel):
+    file_path: str
+    type: Literal['ReadImage'] = 'ReadImage'
+
+
+def serve_image_in_bg(file_path: str, client_uuid: str, name: str) -> None:
+    if not client_uuid:
+        client_uuid = str(uuid.uuid4())
+
+    server_url = "wss://wcgw.arcfu.com/register_serve_image"
+
+    with open(file_path, "rb") as image_file:
+        image_bytes = image_file.read()
+        media_type = mimetypes.guess_type(file_path)[0]
+        image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+        uu = {"name": name, "image_b64": image_b64, "media_type": media_type}
+
+    with syncconnect(f"{server_url}/{client_uuid}") as websocket:
+        try:
+            websocket.send(json.dumps(uu))
+        except websockets.ConnectionClosed:
+            print(f"Connection closed for UUID: {client_uuid}, retrying")
+            serve_image_in_bg(file_path, client_uuid, name)
+
+class ImageData(BaseModel):
+    dataurl: str
+
+
+
 Param = ParamSpec("Param")
 
 T = TypeVar("T")
@@ -229,7 +272,7 @@ def ensure_no_previous_output(func: Callable[Param, T]) -> Callable[Param, T]:
     def wrapper(*args: Param.args, **kwargs: Param.kwargs) -> T:
         global BASH_STATE
         if BASH_STATE == "waiting_for_input":
-            raise ValueError(WETTING_INPUT_MESSAGE)
+            raise ValueError(WAITING_INPUT_MESSAGE)
         elif BASH_STATE == "wont_exit":
             raise ValueError(
                 "A command is already running that hasn't exited. NOTE: You can't run multiple shell sessions, likely the previous program is in infinite loop. Please kill the previous program by sending ctrl+c first."
@@ -238,6 +281,24 @@ def ensure_no_previous_output(func: Callable[Param, T]) -> Callable[Param, T]:
 
     return wrapper
 
+@ensure_no_previous_output
+def read_image_from_shell(file_path: str) -> ImageData:
+    if not os.path.isabs(file_path):
+        SHELL.sendline("pwd")
+        SHELL.expect("#@@")
+        assert isinstance(SHELL.before, str)
+        current_dir = SHELL.before.strip()
+        file_path = os.path.join(current_dir, file_path)
+
+    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(dataurl=f'data:{image_type};base64,{image_b64}')
+    
 
 @ensure_no_previous_output
 def write_file(writefile: Writefile) -> str:
@@ -280,41 +341,24 @@ def take_help_of_ai_assistant(
     return output, cost
 
 
-class AddTasks(BaseModel):
-    task_statement: str
-
-
-def add_task(addtask: AddTasks) -> str:
-    petname_id = petname.Generate(2, "-")
-    return petname_id
-
-
-class RemoveTask(BaseModel):
-    task_id: str
-
-
-def remove_task(removetask: RemoveTask) -> str:
-    return "removed"
-
-
 def which_tool(args: str) -> BaseModel:
     adapter = TypeAdapter[
-        Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag
-    ](Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag)
+        Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag | ReadImage
+    ](Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag | ReadImage)
     return adapter.validate_python(json.loads(args))
 
 
 def get_tool_output(
-    args: dict | Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag,
+    args: dict | Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag | ReadImage,
     enc: tiktoken.Encoding,
     limit: float,
     loop_call: Callable[[str, float], tuple[str, float]],
     is_waiting_user_input: Callable[[str], tuple[BASH_CLF_OUTPUT, float]],
-) -> tuple[str | DoneFlag, float]:
+) -> tuple[str | ImageData | DoneFlag, float]:
     if isinstance(args, dict):
         adapter = TypeAdapter[
-            Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag
-        ](Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag)
+            Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag | ReadImage
+        ](Confirmation | ExecuteBash | Writefile | AIAssistant | DoneFlag | ReadImage)
         arg = adapter.validate_python(args)
     else:
         arg = args
@@ -334,12 +378,9 @@ def get_tool_output(
     elif isinstance(arg, AIAssistant):
         console.print("Calling AI assistant tool")
         output = take_help_of_ai_assistant(arg, limit, loop_call)
-    elif isinstance(arg, AddTasks):
-        console.print("Calling add task tool")
-        output = add_task(arg), 0
-    elif isinstance(arg, get_output_of_last_command):
-        console.print("Calling get output of last program tool")
-        output = get_output_of_last_command(enc), 0
+    elif isinstance(arg, ReadImage):
+        console.print("Calling read image tool")
+        output = read_image_from_shell(arg.file_path), 0.0
     else:
         raise ValueError(f"Unknown tool: {arg}")
 
@@ -353,9 +394,9 @@ History = list[ChatCompletionMessageParam]
 def get_is_waiting_user_input(model: Models, cost_data: CostData):
     enc = tiktoken.encoding_for_model(model if not model.startswith("o1") else "gpt-4o")
     system_prompt = """You need to classify if a bash program is waiting for user input based on its stdout, or if it won't exit. You'll be given the output of any program.
-    Return `waiting_for_input` if the program is waiting for INTERACTIVE input only, Return false if it's waiting for external resources or just waiting to finish.
+    Return `waiting_for_input` if the program is waiting for INTERACTIVE input only, Return 'running' if it's waiting for external resources or just waiting to finish.
     Return `wont_exit` if the program won't exit, for example if it's a server.
-    Return `normal` otherwise.
+    Return `running` otherwise.
     """
     history: History = [{"role": "system", "content": system_prompt}]
     client = OpenAI()
@@ -402,36 +443,35 @@ def execute_user_input() -> None:
     while True:
         discard_input()
         user_input = input()
-        if user_input:
-            with execution_lock:
-                try:
-                    console.log(
-                        execute_bash(
-                            default_enc,
-                            ExecuteBash(
-                                send_ascii=[ord(x) for x in user_input] + [ord("\n")]
-                            ),
-                            lambda x: ("wont_exit", 0),
-                        )[0]
-                    )
-                except Exception as e:
-                    traceback.print_exc()
-                    console.log(f"Error: {e}")
-
-
-async def register_client(server_url: str) -> None:
+        with execution_lock:
+            try:
+                console.log(
+                    execute_bash(
+                        default_enc,
+                        ExecuteBash(
+                            send_ascii=[ord(x) for x in user_input] + [ord("\n")]
+                        ),
+                        lambda x: ("waiting_for_input", 0),
+                    )[0]
+                )
+            except Exception as e:
+                traceback.print_exc()
+                console.log(f"Error: {e}")
+
+
+async def register_client(server_url: str, client_uuid: str = "") -> None:
     global default_enc, default_model, curr_cost
     # Generate a unique UUID for this client
-    client_uuid = str(uuid.uuid4())
-    print(f"Connecting with UUID: {client_uuid}")
+    if not client_uuid:
+        client_uuid = str(uuid.uuid4())
 
     # Create the WebSocket connection
     async with websockets.connect(f"{server_url}/{client_uuid}") as websocket:
+        print(f"Connected. Share this user id with the chatbot: {client_uuid} \nLink: https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access")
         try:
             while True:
                 # Wait to receive data from the server
                 message = await websocket.recv()
-                print(message, type(message))
                 mdata = Mdata.model_validate_json(message)
                 with execution_lock:
                     # is_waiting_user_input = get_is_waiting_user_input(
@@ -454,8 +494,9 @@ async def register_client(server_url: str) -> None:
                     assert not isinstance(output, DoneFlag)
                     await websocket.send(output)
 
-        except websockets.ConnectionClosed:
-            print(f"Connection closed for UUID: {client_uuid}")
+        except (websockets.ConnectionClosed, ConnectionError):
+            print(f"Connection closed for UUID: {client_uuid}, retrying")
+            await register_client(server_url, client_uuid)
 
 
 def run() -> None:
@@ -463,4 +504,12 @@ def run() -> None:
         server_url = sys.argv[1]
     else:
         server_url = "wss://wcgw.arcfu.com/register"
-    asyncio.run(register_client(server_url))
+
+    thread1 = threading.Thread(target=execute_user_input)
+    thread2 = threading.Thread(target=asyncio.run, args=(register_client(server_url),))
+
+    thread1.start()
+    thread2.start()
+
+    thread1.join()
+    thread2.join()

{wcgw-0.0.5.dist-info → wcgw-0.0.7.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.3
 Name: wcgw
-Version: 0.0.5
+Version: 0.0.7
 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.7
+Requires-Python: >=3.8
+Requires-Dist: anthropic>=0.36.2
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: mypy>=1.11.2
 Requires-Dist: openai>=1.46.0
@@ -22,10 +23,18 @@ Requires-Dist: uvicorn>=0.31.0
 Requires-Dist: websockets>=13.1
 Description-Content-Type: text/markdown
 
-# Giving full shell access to Chatgpt web (What could go wrong?)
-Steps: 
-1. First run the client in any directory of choice
-2. Use this custom gpt `https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access` to let it interact with your shell.
+# Shell access to chatgpt.com
+
+### 🚀 Highlights
+- ⚡ **Full Shell Access**: No restrictions, complete control.
+- ⚡ **Create, Execute, Iterate**: Seamless workflow for development and execution.
+- ⚡ **Interactive Command Handling**: Supports interactive commands with ease.
+
+
+###  🪜 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 the GPT: `https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access`
+3. The custom GPT can now run any command on your cli
 
 ## Client
 
@@ -49,7 +58,7 @@ https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access
 
 Add user id the client generated to the first message along with the instructions.
 
-# How does it work?
+# How it works
 Your commands are relayed through a server I've hosted at https://wcgw.arcfu.com. The code for that is at `src/relay/serve.py`. 
 
 The user id that you share with chatgpt is added in the request it sents to the relay server which holds a websocket with the terminal client.

wcgw-0.0.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+wcgw/__init__.py,sha256=okSsOWpTKDjEQzgOin3Kdpx4Mc3MFX1RunjopHQSIWE,62
+wcgw/__main__.py,sha256=MjJnFwfYzA1rW47xuSP1EVsi53DTHeEGqESkQwsELFQ,34
+wcgw/basic.py,sha256=o_iyg3Rmqz08LTWzgO7JIA0u_5l6GGaXyJe0zw73v8w,15085
+wcgw/common.py,sha256=gHiP1RVHkvp10jPc1Xzg5DtUqhGbgQ7pTJK7OvUXfZQ,1764
+wcgw/openai_utils.py,sha256=YNwCsA-Wqq7jWrxP0rfQmBTb1dI0s7dWXzQqyTzOZT4,2629
+wcgw/tools.py,sha256=ozJtcuOlMrdGoDmSv4UpolnStdY7Xz8Z7JyrRllKA7s,17088
+wcgw-0.0.7.dist-info/METADATA,sha256=Ei676pDMqOXetAPPmxU5wAXZ6mWRJfLq8eJHyhfKSTY,2022
+wcgw-0.0.7.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+wcgw-0.0.7.dist-info/entry_points.txt,sha256=T-IH7w6Vc650hr8xksC8kJfbJR4uwN8HDudejwDwrNM,59
+wcgw-0.0.7.dist-info/RECORD,,

wcgw-0.0.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-wcgw/__init__.py,sha256=okSsOWpTKDjEQzgOin3Kdpx4Mc3MFX1RunjopHQSIWE,62
-wcgw/__main__.py,sha256=MjJnFwfYzA1rW47xuSP1EVsi53DTHeEGqESkQwsELFQ,34
-wcgw/basic.py,sha256=BiVjIwrtiz93SkUedDXSwtfVMKoV8-zEWeFKBIamVSQ,12372
-wcgw/common.py,sha256=jn39zTpaFUO1PWof_z7qBmklaZH5G1blzjlBvez0cg4,1225
-wcgw/openai_adapters.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcgw/openai_utils.py,sha256=4Hr9S2-WT8xhDdu3b2YVoX1l9AVxwCFdi_GJbQAx7Us,2202
-wcgw/tools.py,sha256=IHCMbB8Eg1LFhY0sI3e0CMUuGWXCdU7-168efpTk9eo,15155
-wcgw-0.0.5.dist-info/METADATA,sha256=_HvXQu02oMxiFjtBkJ1wJsAMDjFEkMn7nt4c8noa-c0,1669
-wcgw-0.0.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-wcgw-0.0.5.dist-info/entry_points.txt,sha256=T-IH7w6Vc650hr8xksC8kJfbJR4uwN8HDudejwDwrNM,59
-wcgw-0.0.5.dist-info/RECORD,,