wcgw 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

wcgw/common.py

@@ -23,25 +23,27 @@ Models = Literal["gpt-4o-2024-08-06", "gpt-4o-mini"]
 
 
 def discard_input() -> None:
-    # Get the file descriptor for stdin
-    fd = sys.stdin.fileno()
-
-    # Save current terminal settings
-    old_settings = termios.tcgetattr(fd)
-
     try:
-        # Switch terminal to non-canonical mode where input is read immediately
-        tty.setcbreak(fd)
-
-        # Discard all input
-        while True:
-            # Check if there is input to be read
-            if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
-                sys.stdin.read(
-                    1
-                )  # Read one character at a time to flush the input buffer
-            else:
-                break
-    finally:
-        # Restore old terminal settings
-        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        # Get the file descriptor for stdin
+        fd = sys.stdin.fileno()
+
+        # Save current terminal settings
+        old_settings = termios.tcgetattr(fd)
+
+        try:
+            # Switch terminal to non-canonical mode where input is read immediately
+            tty.setcbreak(fd)
+
+            # Discard all input
+            while True:
+                # Check if there is input to be read
+                if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
+                    sys.stdin.read(1)  # Read one character at a time to flush the input buffer
+                else:
+                    break
+        finally:
+            # Restore old terminal settings
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+    except (termios.error, ValueError) as e:
+        # Handle the error gracefully
+        print(f"Warning: Unable to discard input. Error: {e}")

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,15 +1,27 @@
 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
-import petname  # type: ignore[import]
+import petname  # type: ignore[import-untyped]
 import pexpect
 from typer import Typer
 import websockets
@@ -31,7 +43,7 @@ from .common import CostData, Models, discard_input
 
 from .openai_utils import get_input_cost, get_output_cost
 
-console = rich.console.Console(style="magenta", highlight=False)
+console = rich.console.Console(style="magenta", highlight=False, markup=False)
 
 TIMEOUT = 30
 
@@ -65,14 +77,14 @@ class Writefile(BaseModel):
     file_content: str
 
 
-def start_shell():
+def start_shell() -> pexpect.spawn:
     SHELL = pexpect.spawn(
-        "/bin/bash",
-        env={**os.environ, **{"PS1": "#@@"}},
+        "/bin/bash --noprofile --norc",
+        env={**os.environ, **{"PS1": "#@@"}},  # type: ignore[arg-type]
         echo=False,
         encoding="utf-8",
         timeout=TIMEOUT,
-    )  # type: ignore[arg-type]
+    )
     SHELL.expect("#@@")
     SHELL.sendline("stty -icanon -echo")
     SHELL.expect("#@@")
@@ -82,11 +94,33 @@ 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 $?")
+    # First reset the prompt in case venv was sourced or other reasons.
+    SHELL.sendline('export PS1="#@@"')
     SHELL.expect("#@@")
-    assert isinstance(SHELL.before, str)
-    return int((SHELL.before))
+    # Reset echo also if it was enabled
+    SHELL.sendline("stty -icanon -echo")
+    SHELL.expect("#@@")
+    SHELL.sendline("echo $?")
+    before = ""
+    while not _is_int(before):  # Consume all previous output
+        SHELL.expect("#@@")
+        assert isinstance(SHELL.before, str)
+        # Render because there could be some anscii escape sequences still set like in google colab env
+        before = render_terminal_output(SHELL.before).strip()
+
+    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,41 +131,24 @@ 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"
 
 
-def get_output_of_last_command(enc: tiktoken.Encoding) -> str:
-    global SHELL, BASH_STATE
-    output = render_terminal_output(SHELL.before)
-
-    tokens = enc.encode(output)
-    if len(tokens) >= 2048:
-        output = "...(truncated)\n" + enc.decode(tokens[-2047:])
-
-    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`"""
 
 
 def execute_bash(
-    enc: tiktoken.Encoding,
-    bash_arg: ExecuteBash,
-    is_waiting_user_input: Callable[[str], tuple[BASH_CLF_OUTPUT, float]],
+    enc: tiktoken.Encoding, bash_arg: ExecuteBash, max_tokens: Optional[int]
 ) -> tuple[str, float]:
     global SHELL, BASH_STATE
     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.
@@ -172,46 +189,41 @@ def execute_bash(
         SHELL = start_shell()
         raise
 
-    wait = timeout = 5
+    wait = 5
     index = SHELL.expect(["#@@", pexpect.TIMEOUT], timeout=wait)
     running = ""
     while index == 1:
         if wait > TIMEOUT:
             raise TimeoutError("Timeout while waiting for shell prompt")
 
-        text = SHELL.before
+        BASH_STATE = "waiting_for_input"
+        text = SHELL.before or ""
         print(text[len(running) :])
         running = text
 
         text = render_terminal_output(text)
-        BASH_STATE, cost = is_waiting_user_input(text)
-        if BASH_STATE == "waiting_for_input" or BASH_STATE == "wont_exit":
-            tokens = enc.encode(text)
+        tokens = enc.encode(text)
 
-            if len(tokens) >= 2048:
-                text = "...(truncated)\n" + enc.decode(tokens[-2047:])
+        if max_tokens and len(tokens) >= max_tokens:
+            text = "...(truncated)\n" + enc.decode(tokens[-(max_tokens - 1) :])
 
-            last_line = (
-                "(waiting for input)"
-                if BASH_STATE == "waiting_for_input"
-                else "(won't exit)"
-            )
-            return text + f"\n{last_line}", cost
-        index = SHELL.expect(["#@@", pexpect.TIMEOUT], timeout=wait)
-        wait += timeout
+        last_line = "(pending)"
+        return text + f"\n{last_line}", 0
 
     assert isinstance(SHELL.before, str)
     output = render_terminal_output(SHELL.before)
 
     tokens = enc.encode(output)
-    if len(tokens) >= 2048:
-        output = "...(truncated)\n" + enc.decode(tokens[-2047:])
+    if max_tokens and len(tokens) >= max_tokens:
+        output = "...(truncated)\n" + enc.decode(tokens[-(max_tokens - 1) :])
 
     try:
         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 +232,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 +270,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."
@@ -239,14 +280,33 @@ 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 = render_terminal_output(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:
     if not os.path.isabs(writefile.file_path):
         SHELL.sendline("pwd")
         SHELL.expect("#@@")
         assert isinstance(SHELL.before, str)
-        current_dir = SHELL.before.strip()
-        writefile.file_path = os.path.join(current_dir, writefile.file_path)
+        current_dir = render_terminal_output(SHELL.before).strip()
+        return f"Failure: Use absolute path only. FYI current working directory is '{current_dir}'"
     os.makedirs(os.path.dirname(writefile.file_path), exist_ok=True)
     try:
         with open(writefile.file_path, "w") as f:
@@ -280,51 +340,40 @@ 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[object, object]
+    | 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]:
+    max_tokens: Optional[int],
+) -> 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
-    output: tuple[str | DoneFlag, float]
+    output: tuple[str | DoneFlag | ImageData, float]
     if isinstance(arg, Confirmation):
         console.print("Calling ask confirmation tool")
         output = ask_confirmation(arg), 0.0
     elif isinstance(arg, ExecuteBash):
         console.print("Calling execute bash tool")
-        output = execute_bash(enc, arg, is_waiting_user_input)
+        output = execute_bash(enc, arg, max_tokens)
     elif isinstance(arg, Writefile):
         console.print("Calling write file tool")
         output = write_file(arg), 0
@@ -334,12 +383,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}")
 
@@ -350,12 +396,14 @@ def get_tool_output(
 History = list[ChatCompletionMessageParam]
 
 
-def get_is_waiting_user_input(model: Models, cost_data: CostData):
+def get_is_waiting_user_input(
+    model: Models, cost_data: CostData
+) -> Callable[[str], tuple[BASH_CLF_OUTPUT, float]]:
     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,64 +450,70 @@ 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")]
+                        ),
+                        max_tokens=None,
+                    )[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(
-                        default_model, default_cost
-                    )
                     try:
                         output, cost = get_tool_output(
-                            mdata.data,
-                            default_enc,
-                            0.0,
-                            lambda x, y: ("", 0),
-                            is_waiting_user_input,
+                            mdata.data, default_enc, 0.0, lambda x, y: ("", 0), None
                         )
                         curr_cost += cost
                         print(f"{curr_cost=}")
                     except Exception as e:
                         output = f"GOT EXCEPTION while calling tool. Error: {e}"
                         traceback.print_exc()
-                    assert not isinstance(output, DoneFlag)
+                    assert isinstance(output, str)
                     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:
-    if len(sys.argv) > 1:
-        server_url = sys.argv[1]
-    else:
-        server_url = "ws://localhost:8000/register"
-    asyncio.run(register_client(server_url))
+run = Typer(pretty_exceptions_show_locals=False, no_args_is_help=True)
+
+
+@run.command()
+def app(
+    server_url: str = "wss://wcgw.arcfu.com/register", client_uuid: Optional[str] = None
+) -> None:
+    thread1 = threading.Thread(target=execute_user_input)
+    thread2 = threading.Thread(
+        target=asyncio.run, args=(register_client(server_url, client_uuid or ""),)
+    )
+
+    thread1.start()
+    thread2.start()
+
+    thread1.join()
+    thread2.join()

wcgw-0.1.2.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.3
+Name: wcgw
+Version: 0.1.2
+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-Dist: fastapi>=0.115.0
+Requires-Dist: mypy>=1.11.2
+Requires-Dist: openai>=1.46.0
+Requires-Dist: petname>=2.6
+Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: pyte>=0.8.2
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: rich>=13.8.1
+Requires-Dist: shell>=1.0.1
+Requires-Dist: tiktoken==0.7.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: types-pexpect>=4.9.0.20240806
+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.
+
+[![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)
+
+### 🚀 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**: [beta] Supports interactive commands using arrow keys, interrupt, and ansi escape sequences. 
+
+###  🪜 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
+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]
+```sh
+$ curl -LsSf https://astral.sh/uv/install.sh | sh
+$ uv tool run --python 3.12 wcgw@latest
+```
+
+### 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
+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 
+`wcgw --client-uuid $previous_uuid`
+
+# How it works
+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. 
+
+# Showcase
+
+## 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)
+
+
+# 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 
+`gunicorn --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:443 src.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.
+
+The specify the server url in the `wcgw` command like so
+`wcgw --server-url https://your-url/register`
+
+# [Optional] Local shell access with openai API key
+
+Add `OPENAI_API_KEY` and `OPENAI_ORG_ID` env variables.
+
+Clone the repo and run to install `wcgw_local` command
+
+`pip install .`
+
+Then run 
+
+`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.