updates

ui/.gitignore

@@ -0,0 +1 @@
+state/*

ui/api.py

@@ -1,22 +1,41 @@
 import os, sys
 import utils
+import uuid
+import json
+import subprocess, threading
 
 FILE_DIR = os.path.dirname(os.path.abspath(__file__))
 REPO_DIR = os.path.dirname(FILE_DIR)
 sys.path.append(REPO_DIR)
-import threading
-from functools import partial
 import time
 
+
 def get_openai_api_key():
     return os.getenv("OPENAI_API_KEY")
 
+
 running_apis = []
 
+
+def get_state(state_file):
+    with open(state_file, "r") as f:
+        state = json.load(f)
+    return state
+
+
+def set_state(state_file, state):
+    with open(state_file, "w") as f:
+        json.dump(state, f)
+
+
 class AutoAPI:
     def __init__(self, openai_key, ai_name, ai_role, top_5_goals):
-        print(openai_key)
         self.openai_key = openai_key
+        hex = uuid.uuid4().hex
+        print(hex)
+        self.state_file = os.path.join(FILE_DIR, "state", f"state_{hex}.json")
+        self.log_file = os.path.join(FILE_DIR, "state", f"log_{hex}.json")
+
         newline = "\n"
         with open(os.path.join(REPO_DIR, "ai_settings.yaml"), "w") as f:
             f.write(
@@ -26,68 +45,99 @@ ai_name: {ai_name}
 ai_role: {ai_role}
 """
             )
+        state = {
+            "pending_input": None,
+            "awaiting_input": False,
+            "messages": [],
+            "last_message_read_index": -1,
+        }
+        set_state(self.state_file, state)
 
-
-        thread = threading.Thread(target=self.client_thread)
-        thread.start()
-        self.thread = thread
-        self.pending_input = None
-        self.awaiting_input = False
-        self.messages = []
-        self.last_message_read_index = -1
-
-    def add_message(self, title, content):
-        # print(f"{title}: {content}")
-        self.messages.append((title, content))
-
-    def client_thread(self):
-        os.environ["OPENAI_API_KEY"] = self.openai_key
-        import autogpt.config.config
-        from autogpt.logs import logger
-        from autogpt.cli import main
-        import autogpt.utils
-        from autogpt.spinner import Spinner
-
-
-        def typewriter_log(self, title="", title_color="", content="", *args, **kwargs):
-            self.add_message(title, content)
-
-        def warn(self, message, title="", *args, **kwargs):
-            self.add_message(title, message)
-    
-        def error(self, title, message="", *args, **kwargs):
-            self.add_message(title, message)
-
-        def clean_input(self, prompt=""):
-            self.add_message(None, prompt)
-            self.awaiting_input = True
-            while self.pending_input is None:
-                time.sleep(1)
-            pending_input = self.pending_input
-            self.pending_input = None
-            print("Sending message:", pending_input)
-            return pending_input
-        
-        def spinner_start(self):
-            self.add_message(None, "Thinking...")
-        
-        logger.typewriter_log = partial(typewriter_log, self)
-        logger.warn = partial(warn, self)
-        logger.error = partial(error, self)
-        autogpt.utils.clean_input = partial(clean_input, self)
-        Spinner.spin = partial(spinner_start, self)
-
-        main()
+        with open(self.log_file, "w") as f:
+            subprocess.Popen(
+                [
+                    "python",
+                    os.path.join(REPO_DIR, "ui", "api.py"),
+                    openai_key,
+                    self.state_file,
+                ],
+                cwd=REPO_DIR,
+                stdout=f,
+                stderr=f,
+            )
 
     def send_message(self, message="Y"):
-        self.pending_input = message
-        self.awaiting_input = False
+        state = get_state(self.state_file)
+        state["pending_input"] = message
+        state["awaiting_input"] = False
+        set_state(self.state_file, state)
 
     def get_chatbot_response(self):
-        while (not self.awaiting_input) or self.last_message_read_index < len(self.messages) - 1:
-            if self.last_message_read_index >= len(self.messages) - 1:
+        while True:
+            state = get_state(self.state_file)
+            if (
+                state["awaiting_input"]
+                and state["last_message_read_index"] >= len(state["messages"]) - 1
+            ):
+                break
+            if state["last_message_read_index"] >= len(state["messages"]) - 1:
                 time.sleep(1)
             else:
-                self.last_message_read_index += 1
-                title, content = self.messages[self.last_message_read_index]
-                yield (f"**{title.strip()}** " if title else "") + utils.remove_color(content).replace("\n", "<br />")
+                state["last_message_read_index"] += 1
+                title, content = state["messages"][state["last_message_read_index"]]
+                yield (f"**{title.strip()}** " if title else "") + utils.remove_color(
+                    content
+                ).replace("\n", "<br />")
+                set_state(self.state_file, state)
+
+
+if __name__ == "__main__":
+    print(sys.argv)
+    _, openai_key, state_file = sys.argv
+    os.environ["OPENAI_API_KEY"] = openai_key
+    import autogpt.config.config
+    from autogpt.logs import logger
+    from autogpt.cli import main
+    import autogpt.utils
+    from autogpt.spinner import Spinner
+
+    def add_message(title, content):
+        state = get_state(state_file)
+        state["messages"].append((title, content))
+        set_state(state_file, state)
+
+    def typewriter_log(title="", title_color="", content="", *args, **kwargs):
+        add_message(title, content)
+
+    def warn(message, title="", *args, **kwargs):
+        add_message(title, message)
+
+    def error(title, message="", *args, **kwargs):
+        add_message(title, message)
+
+    def clean_input(prompt=""):
+        add_message(None, prompt)
+        state = get_state(state_file)
+        state["awaiting_input"] = True
+        set_state(state_file, state)
+        while state["pending_input"] is None:
+            state = get_state(state_file)
+            print("Waiting for input...")
+            time.sleep(1)
+        print("Got input")
+        pending_input = state["pending_input"]
+        state["pending_input"] = None
+        set_state(state_file, state)
+        return pending_input
+
+    def spinner_start():
+        add_message(None, "Thinking...")
+
+    logger.typewriter_log = typewriter_log
+    logger.warn = warn
+    logger.error = error
+    autogpt.utils.clean_input = clean_input
+    Spinner.spin = spinner_start
+
+    sys.argv = sys.argv[:1]
+    main()