Actually send the puppet reads

Deploy to hugging face
Add history
Add commands

.github/workflows/cd.yml

@@ -0,0 +1,21 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run:
+          git push https://posix4e:$HF_TOKEN@huggingface.co/spaces/posix4e/puppet main

.github/workflows/release_ci.yml

@@ -32,14 +32,6 @@ jobs:
           distribution: 'temurin'
           cache: gradle
 
-      - name: Create file
-        run: cat /home/runner/work/puppet/puppet/puppet/app/google-services.json | base64
-
-      - name: Putting data
-        env:
-          DATA: ${{ secrets.GOOGLE_SERVICES_JSON }}
-        run: echo $DATA > /home/runner/work/puppet/puppet/puppet/app/google-services.json
-
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 

.gitignore

@@ -0,0 +1,2 @@
+**/*.swp
+.vscode

README.md

@@ -1 +1,23 @@
-# puppet
+---
+title: puppet 
+colorTo: indigo
+app_file: backend/backend.py
+sdk: gradio
+sdk_version: 3.36.1
+python_version: 3.11.2
+pinned: false
+license: mit
+---
+
+Fun!
+
+## MVP
+- [ ] switch to only rpcing every minute 
+- [ ] Run commands on android
+- [x] Fix assist on android
+- [ ] Testing
+- [ ] Docs
+
+## Todo Soon
+
+- [ ] Other clients (browser extension/watch)

backend/backend.py

@@ -1,144 +1,386 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from firebase_admin import credentials, messaging, initialize_app, auth
-import openai
-import asyncio
+import json
+import uuid
+from datetime import datetime
+
 import gradio as gr
-from fastapi.middleware.wsgi import WSGIMiddleware
-from fastapi.staticfiles import StaticFiles
-import uvicorn
+import mistune
+import openai
 from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.testclient import TestClient
+from pydantic import BaseModel
+from pygments import highlight
+from pygments.formatters import html
+from pygments.lexers import get_lexer_by_name
+from sqlalchemy import JSON, Column, Integer, String, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.sql import insert, select, text
+from uvicorn import Config, Server
+from fastapi.middleware.gzip import GZipMiddleware
+
+LANGS = [
+    "text-davinci-002:100",
+    "text-davinci-003:1500",
+    "gpt-3.5-turbo:4000",
+    "gpt-4:6000",
+]
+
+Base = declarative_base()
+
+
+class User(Base):
+    __tablename__ = "user_data"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    uid = Column(String, nullable=False)
+    openai_key = Column(String)
+
+    def __repr__(self):
+        return f"User(id={self.id}, uid={self.uid}"
+
+
+class History(Base):
+    __tablename__ = "history"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    uid = Column(String, nullable=False)
+    question = Column(String, nullable=False)
+    answer = Column(JSON, nullable=False)
+
+    def __repr__(self):
+        return f"History(id={self.id}, uid={self.uid}, question={self.question}, answer={self.answer}"
+
+
+# Add a new table to store the commands
+class Command(Base):
+    __tablename__ = "commands"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    uid = Column(String, nullable=False)
+    command = Column(String, nullable=False)
+    status = Column(String, nullable=False, default="queued")
+
+    def __repr__(self):
+        return f"self.command"
+
+
+engine = create_engine("sqlite:///puppet.db")
+Base.metadata.create_all(bind=engine)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 load_dotenv()
 
+app = FastAPI(debug=True)
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+
 
-app = FastAPI()
+# Add a new API endpoint to add commands to the queue
+class CommandItem(BaseModel):
+    uid: str
+    command: str
+
+
+@app.post("/add_command")
+async def add_command(item: CommandItem):
+    db: Session = SessionLocal()
+    new_command = Command(uid=item.uid, command=item.command)
+    db.add(new_command)
+    db.commit()
+    db.refresh(new_command)
+    return {"message": "Command added"}
+
+
+class EventItem(BaseModel):
+    uid: str
+    event: str
+
+
+@app.post("/send_event")
+async def send_event(item: EventItem):
+    print(f"Received event from {item.uid}:\n{item.event}")
+
+    with open(f"{item.uid}_events.txt", "a") as f:
+        f.write(f"{datetime.now()} - {item.event}\n")
+
+    db: Session = SessionLocal()
+    user = db.query(User).filter(User.uid == item.uid).first()
+    if not user:
+        raise HTTPException(status_code=400, detail="Invalid uid")
+
+    # Update the last time send_event was called and increment the number of events
+    user.last_event = datetime.now()
+    db.commit()
 
-# User credentials will be stored in this dictionary
-user_data = {}
+    # Get all the queued commands for this user
+    commands = (
+        db.query(Command)
+        .filter(Command.uid == item.uid, Command.status == "queued")
+        .all()
+    )
+    for command in commands:
+        command.status = "running"
+    db.commit()
+
+    return {
+        "message": "Event received",
+        "commands": [command.command for command in commands],
+    }
 
 
 class RegisterItem(BaseModel):
-    apiKey: str
-    authDomain: str
-    databaseURL: str
-    storageBucket: str
+    openai_key: str
 
 
 @app.post("/register")
 async def register(item: RegisterItem):
-    # Firebase initialization with user-specific credentials
-    cred = credentials.Certificate(
-        {
-            "apiKey": item.apiKey,
-            "authDomain": item.authDomain,
-            "databaseURL": item.databaseURL,
-            "storageBucket": item.storageBucket,
-        }
-    )
-    firebase_app = initialize_app(cred, name=str(len(user_data)))
-    # Add the Firebase app and auth details to the user_data dictionary
-    user_data[str(len(user_data))] = {
-        "firebase_app": firebase_app,
-        "authDomain": item.authDomain,
-    }
-    return {"uid": str(len(user_data) - 1)}  # Return the user ID
+    db: Session = SessionLocal()
+    new_user = User(uid=str(uuid.uuid4()), openai_key=item.openai_key)
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    return {"uid": new_user.uid}
 
 
-class ProcessItem(BaseModel):
+class AssistItem(BaseModel):
     uid: str
     prompt: str
+    version: str
 
 
-@app.post("/process_request")
-async def process_request(item: ProcessItem):
-    # Get the user's Firebase app from the user_data dictionary
-    firebase_app = user_data.get(item.uid, {}).get("firebase_app", None)
-    authDomain = user_data.get(item.uid, {}).get("authDomain", None)
+def generate_quick_completion(prompt, model):
+    dropdrown = model.split(":")
+    engine = dropdrown[0]
+    max_tokens = int(dropdrown[1])
+    if "gpt" in model:
+        message = [{"role": "user", "content": prompt}]
+        response = openai.ChatCompletion.create(
+            model=engine,
+            messages=message,
+            temperature=0.2,
+            max_tokens=max_tokens,
+            frequency_penalty=0.0,
+        )
+    elif "davinci" in model:
+        response = openai.Completion.create(
+            engine=engine, prompt=prompt, max_tokens=max_tokens
+        )
+    else:
+        raise Exception("Unknown model")
+    return response
 
-    if not firebase_app or not authDomain:
+
+@app.post("/assist")
+async def assist(item: AssistItem):
+    db: Session = SessionLocal()
+    user = db.query(User).filter(User.uid == item.uid).first()
+    if not user:
         raise HTTPException(status_code=400, detail="Invalid uid")
 
     # Call OpenAI
-    response = openai.Completion.create(
-        engine="text-davinci-002", prompt=item.prompt, max_tokens=150
+    openai.api_key = user.openai_key
+    response = generate_quick_completion(item.prompt, item.version)
+
+    # Update the last time assist was called
+    user.last_assist = datetime.now()
+
+    # Store the history
+    new_history = History(
+        uid=item.uid, question=item.prompt, answer=json.loads(str(response))
     )
 
-    # The message data that will be sent to the client
-    message = messaging.Message(
-        data={
-            "message": response.choices[0].text.strip(),
-        },
-        topic="updates",
-        app=firebase_app,  # Use the user-specific Firebase app
+    db.add(new_history)
+    db.commit()
+
+    return response
+
+
+@app.get("/get_history/{uid}")
+async def get_history(uid: str):
+    db: Session = SessionLocal()
+    history = db.query(History).filter(History.uid == uid).all()
+    commands = db.query(Command).filter(Command.uid == uid).all()
+    if not history:
+        raise HTTPException(status_code=400, detail="No history found for this uid")
+    ret = {"history": [h.__dict__ for h in history]}
+
+    if commands and len(commands) > 0:
+        try:
+            with open(f"{uid}_events.txt", "r") as f:
+                events = f.read().split()
+        except FileNotFoundError:
+            events = None
+
+        return {
+            "events": events,
+            "history": [h.__dict__ for h in history],
+            "commands": [c.__dict__ for c in commands],
+        }
+
+    else:
+        return {"history": [h.__dict__ for h in history]}
+
+
+def assist_interface(uid, prompt, gpt_version):
+    client = TestClient(app)
+
+    response = client.post(
+        "/assist",
+        json={"uid": uid, "prompt": prompt, "version": gpt_version},
     )
+    return display_json(response.text)
 
-    # Send the message asynchronously
-    asyncio.run(send_notification(message))
 
-    return {"message": "Notification sent"}
+def get_user_interface(uid):
+    db: Session = SessionLocal()
+    user = db.query(User).filter(User.uid == uid).first()
+    if not user:
+        return {"message": "No user with this uid found"}
+    return str(user)
 
 
-def send_notification(message):
-    # Send a message to the devices subscribed to the provided topic.
-    response = messaging.send(message)
-    print("Successfully sent message:", response)
+class HighlightRenderer(mistune.HTMLRenderer):
+    def block_code(self, code, info=None):
+        if info:
+            lexer = get_lexer_by_name(info, stripall=True)
+            formatter = html.HtmlFormatter()
+            return highlight(code, lexer, formatter)
+        return "<pre><code>" + mistune.escape(code) + "</code></pre>"
 
 
-def gradio_interface():
-    def register(apiKey, authDomain, databaseURL, storageBucket):
-        response = requests.post(
-            "http://localhost:8000/register",
-            json={
-                "apiKey": apiKey,
-                "authDomain": authDomain,
-                "databaseURL": databaseURL,
-                "storageBucket": storageBucket,
-            },
-        )
-        return response.json()
+def display_json(data):
+    html_output = "<html>"
+    json_data = json.loads(data)
 
-    def process_request(uid, prompt):
-        response = requests.post(
-            "http://localhost:8000/process_request", json={"uid": uid, "prompt": prompt}
-        )
-        return response.json()
+    id = json_data["id"]
+    object = json_data["object"]
+    created = json_data["created"]
+    model = json_data["model"]
+    choices = json_data["choices"]
+
+    html_output += f"<h2>ID: {id}</h2>"
+    html_output += f"<p>Object: {object}</p>"
+    html_output += f"<p>Created: {created}</p>"
+    html_output += f"<p>Model: {model}</p>"
+
+    html_output += "<h3>Choices:</h3>"
+    if "davinci" in model:
+        for choice in choices:
+            text = choice["text"]
+            html_output += f"<p>Text: {text}</p>"
+    elif "gpt" in model:
+        for choice in choices:
+            try:
+                markdown = mistune.create_markdown(renderer=HighlightRenderer())
+                text = markdown(choice["message"]["content"])
+                html_output += f"<p>Text: {text}</p>"
+            except:
+                markdown = mistune.create_markdown()
+                text = markdown(choice["message"]["content"])
+                html_output += f"<p>Text: {text}</p>"
+
+    html_output += "</html>"
+    return html_output
+
+
+def get_assist_interface():
+    gpt_version_dropdown = gr.inputs.Dropdown(label="GPT Version", choices=LANGS)
 
-    demo = gr.Interface(
-        fn=[register, process_request],
+    return gr.Interface(
+        fn=assist_interface,
         inputs=[
-            [
-                gr.inputs.Textbox(label="apiKey"),
-                gr.inputs.Textbox(label="authDomain"),
-                gr.inputs.Textbox(label="databaseURL"),
-                gr.inputs.Textbox(label="storageBucket"),
-            ],
-            [gr.inputs.Textbox(label="uid"), gr.inputs.Textbox(label="prompt")],
+            gr.inputs.Textbox(label="UID", type="text"),
+            gr.inputs.Textbox(label="Prompt", type="text"),
+            gpt_version_dropdown,
         ],
+        outputs="html",
+        title="OpenAI Text Generation",
+        description="Generate text using OpenAI's GPT-4 model.",
+    )
+
+
+def get_db_interface():
+    return gr.Interface(
+        fn=get_user_interface,
+        inputs="text",
+        outputs="text",
+        title="Get User Details",
+        description="Get user details from the database",
+    )
+
+
+def register_interface(openai_key):
+    client = TestClient(app)
+    response = client.post(
+        "/register",
+        json={"openai_key": openai_key},
+    )
+    return response.json()
+
+
+def get_register_interface():
+    return gr.Interface(
+        fn=register_interface,
+        inputs=[gr.inputs.Textbox(label="OpenAI Key", type="text")],
         outputs="json",
-        title="API Explorer",
-        description="Use this tool to make requests to the Register and Process Request APIs",
+        title="Register New User",
+        description="Register a new user by entering an OpenAI key.",
     )
-    return demo
 
 
-def process_request_interface(uid, prompt):
-    item = ProcessItem(uid=uid, prompt=prompt)
-    response = process_request(item)
-    return response
+def get_history_interface(uid):
+    client = TestClient(app)
+    response = client.get(f"/get_history/{uid}")
+    return response.json()
+
 
+def get_history_gradio_interface():
+    return gr.Interface(
+        fn=get_history_interface,
+        inputs=[gr.inputs.Textbox(label="UID", type="text")],
+        outputs="json",
+        title="Get User History",
+        description="Get the history of questions and answers for a given user.",
+    )
+
+
+def add_command_interface(uid, command):
+    client = TestClient(app)
+    response = client.post(
+        "/add_command",
+        json={"uid": uid, "command": command},
+    )
+    return response.json()
 
-def get_gradle_interface():
+
+def get_add_command_interface():
     return gr.Interface(
-        fn=process_request_interface,
+        fn=add_command_interface,
         inputs=[
             gr.inputs.Textbox(label="UID", type="text"),
-            gr.inputs.Textbox(label="Prompt", type="text"),
+            gr.inputs.Textbox(label="Command", type="text"),
         ],
-        outputs="text",
-        title="OpenAI Text Generation",
-        description="Generate text using OpenAI's GPT-3 model.",
+        outputs="json",
+        title="Add Command",
+        description="Add a new command for a given user.",
     )
 
 
-app = gr.mount_gradio_app(app, get_gradle_interface(), path="/")
+app = gr.mount_gradio_app(
+    app,
+    gr.TabbedInterface(
+        [
+            get_assist_interface(),
+            get_db_interface(),
+            get_register_interface(),
+            get_history_gradio_interface(),
+            get_add_command_interface(),
+        ]
+    ),
+    path="/",
+)
+
+if __name__ == "__main__":
+    config = Config("backend:app", host="0.0.0.0", port=7860, reload=True)
+    server = Server(config)
+    server.run()

backend/crappy_test.py

@@ -1,21 +1,35 @@
-import time
-from fastapi.testclient import TestClient
+import uuid
+
 import pytest
-import json
+from fastapi.testclient import TestClient
+
 import backend
-import httpx
+
+client = TestClient(backend.app)
 
 
 @pytest.mark.asyncio
 async def test_register():
-    client = TestClient(backend.app)
+    data = {
+        "openai_key": "garbage",
+    }
+    client.post("/register", json=data)
 
+
+@pytest.mark.asyncio
+async def test_send_event():
+    data = {
+        "uid": str(uuid.uuid4()),
+        "event": "test event",
+    }
+    client.post("/register", json=data)
+
+
+@pytest.mark.asyncio
+async def test_assist():
     data = {
-        "apiKey": "test-api-key",
-        "authDomain": "test-auth-domain",
-        "databaseURL": "test-database-url",
-        "storageBucket": "test-storage-bucket",
-        "openai_key": "test-openai-key",
+        "uid": str(uuid.uuid4()),
+        "prompt": "test prompt",
+        "version": "davinci-fake",
     }
-    with pytest.raises(ValueError):
-        client.post("/register", json=data)
+    client.post("/assist", json=data)

backend/requirements.txt

@@ -1,12 +1,15 @@
 fastapi
 firebase-admin
 flask
-gradio
+gradio >= 3.36.1
 httpx
 openai
 pinecone-io
 pydantic
+pygments
 python-dotenv
+mistune
+sqlalchemy
 swagger-ui-bundle
 
 pytest-asyncio 

puppet/.gitignore

@@ -3,12 +3,6 @@ app/google-services.json
 *.iml
 .gradle
 local.properties
-.idea/caches
-.idea/libraries
-.idea/modules.xml
-.idea/workspace.xml
-.idea/navEditor.xml
-.idea/assetWizardSettings.xml
+.idea/**
 .DS_Store
 build
-local.properties

puppet/.idea/.gitignore

@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml

puppet/.idea/androidTestResultsUserPreferences.xml

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AndroidTestResultsUserPreferences">
-    <option name="androidTestResultsTableState">
-      <map>
-        <entry key="-311158389">
-          <value>
-            <AndroidTestResultsTableState>
-              <option name="preferredColumnWidths">
-                <map>
-                  <entry key="Duration" value="90" />
-                  <entry key="Pixel_3a_API_32" value="120" />
-                  <entry key="Tests" value="360" />
-                </map>
-              </option>
-            </AndroidTestResultsTableState>
-          </value>
-        </entry>
-        <entry key="616020959">
-          <value>
-            <AndroidTestResultsTableState>
-              <option name="preferredColumnWidths">
-                <map>
-                  <entry key="Duration" value="90" />
-                  <entry key="Pixel_3a_API_32" value="120" />
-                  <entry key="Tests" value="360" />
-                </map>
-              </option>
-            </AndroidTestResultsTableState>
-          </value>
-        </entry>
-      </map>
-    </option>
-  </component>
-</project>

puppet/.idea/compiler.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="17" />
-  </component>
-</project>

puppet/.idea/gradle.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

puppet/.idea/kotlinc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.9.0" />
-  </component>
-</project>

puppet/.idea/misc.xml

@@ -1,9 +0,0 @@
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>

puppet/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>

puppet/app/build.gradle

@@ -2,12 +2,11 @@
 plugins {
     id 'com.android.application'
     id 'org.jetbrains.kotlin.android'
-    id 'com.google.gms.google-services'
 }
 
 android {
     namespace 'com.ttt246.puppet'
-    compileSdkVersion 33
+    compileSdkVersion 34
     kotlinOptions {
         jvmTarget = "1.8"
     }
@@ -20,7 +19,6 @@ android {
         minSdkVersion 32
         versionCode 1
         versionName "1.0"
-
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -39,13 +37,10 @@ android {
 
 
 dependencies {
-    implementation(platform("com.google.firebase:firebase-bom:32.2.0"))
-    implementation 'com.google.firebase:firebase-analytics-ktx'
-    implementation 'com.google.firebase:firebase-auth-ktx'
-    implementation 'com.google.firebase:firebase-firestore-ktx'
     implementation 'androidx.appcompat:appcompat:1.6.1'
     implementation 'com.google.android.material:material:1.9.0'
-    implementation 'com.google.firebase:firebase-messaging-ktx:23.2.0'
+    implementation 'com.eclipsesource.j2v8:j2v8:6.2.1@aar'
+    implementation 'androidx.core:core-ktx:1.10.1'
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.5'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'

puppet/app/src/main/AndroidManifest.xml

@@ -1,14 +1,17 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
-       <uses-permission android:name="android.permission.BIND_ACCESSIBILITY_SERVICE"
-           tools:ignore="ProtectedPermissions" />
-       <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+   <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.BIND_ACCESSIBILITY_SERVICE"
+        tools:ignore="ProtectedPermissions" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
 
         <application
             android:allowBackup="true"
             android:dataExtractionRules="@xml/data_extraction_rules"
             android:fullBackupContent="@xml/backup_rules"
             android:icon="@mipmap/ic_launcher"
+            android:networkSecurityConfig="@xml/network_security_config"
             android:label="@string/app_name"
             android:roundIcon="@mipmap/ic_launcher_round"
             android:supportsRtl="true"
@@ -22,6 +25,7 @@
                     <category android:name="android.intent.category.LAUNCHER" />
                 </intent-filter>
             </activity>
+            <activity android:name=".SettingsActivity" android:exported="false"/>
 
             <service
                 android:name=".PuppetAS"

puppet/app/src/main/java/com/ttt246/puppet/ChatterAct.kt

@@ -1,54 +1,51 @@
 package com.ttt246.puppet
+
 import android.annotation.SuppressLint
 import android.content.Intent
 import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
+import android.preference.PreferenceManager
 import android.provider.Settings
-import android.view.View
-import android.widget.TextView
+import android.webkit.WebView
+import android.widget.Button
 import androidx.appcompat.app.AppCompatActivity
-import com.google.android.gms.tasks.OnCompleteListener
-import com.google.firebase.messaging.FirebaseMessaging
-import java.io.File
-import java.io.IOException
-
+import com.eclipsesource.v8.V8
 
-@Suppress("DEPRECATION")
 class ChatterAct : AppCompatActivity() {
-    private var fcmToken: String = String()
-    private var uuid: String = String()
+    private lateinit var webView: WebView
 
-    @SuppressLint("HardwareIds")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        // Hide the status bar (system toolbar)
-        window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN
+        setContentView(R.layout.activity_main)
         supportActionBar?.hide()
-
-        initToken()
-        // on below line we are getting device id.
-        uuid = Settings.Secure.getString(contentResolver, Settings.Secure.ANDROID_ID)
         val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
         startActivity(intent)
 
+        val settingsButton: Button = findViewById(R.id.settingsButton)
+        webView = findViewById(R.id.webView)
+
+        val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this)
+        val serverUrl = sharedPreferences.getString("SERVER_URL", "https://default-url-if-not-set.com")
+        if (serverUrl != null) {
+            webView.loadUrl(serverUrl)
+            webView.settings.javaScriptEnabled = true
+            webView.settings.domStorageEnabled = true
+        }
+
+        settingsButton.setOnClickListener {
+            val settingsIntent = Intent(this, SettingsActivity::class.java)
+            startActivity(settingsIntent)
+        }
     }
 
-    private fun initToken() {
-        FirebaseMessaging.getInstance().token.addOnCompleteListener(OnCompleteListener { task ->
-            if (!task.isSuccessful) {
-                return@OnCompleteListener
-            }
-
-            fcmToken = task.result
-        })
-    }
-
-    fun getFCMToken(): String {
-        return this.fcmToken
-    }
-
-    fun getUUID(): String {
-        return this.uuid
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun onResume() {
+        super.onResume()
+        val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this)
+        val serverUrl = sharedPreferences.getString("SERVER_URL", "https://default-url-if-not-set.com")
+        if (serverUrl != null) {
+            webView.settings.javaScriptEnabled = true
+            webView.settings.domStorageEnabled = true
+            webView.loadUrl(serverUrl)
+        }
     }
-}
+}

puppet/app/src/main/java/com/ttt246/puppet/PuppetAS.kt

@@ -1,24 +1,182 @@
 package com.ttt246.puppet
+
 import android.accessibilityservice.AccessibilityService
 import android.app.NotificationChannel
 import android.app.NotificationManager
+import android.content.Intent
+import android.preference.PreferenceManager
 import android.util.Log
 import android.view.accessibility.AccessibilityEvent
 import androidx.core.app.NotificationCompat
-import java.io.File
+import com.eclipsesource.v8.V8
+import com.eclipsesource.v8.V8Function
+import com.eclipsesource.v8.V8Object
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.LinkedList
+import java.util.Queue
+class Americano {
+    private val v8Runtime: V8 = V8.createV8Runtime()
+
+    init {
+        registerJavaMethod()
+    }
+
+    private fun registerJavaMethod() {
+        val javaMethod = V8Function(v8Runtime) { receiver, parameters ->
+            // Your Java method implementation here
+            "Hello, ${parameters.getString(0)}!"
+        }
+
+        v8Runtime.add("myJavaMethod", javaMethod)
+    }
+
+    fun executeScript(script: String): V8Object {
+        val ret =  v8Runtime.executeObjectScript(script)
+        v8Runtime.release()
+        return ret
+
+    }
 
+}
 class PuppetAS : AccessibilityService() {
+    private fun getServerUrl(): String = PreferenceManager.getDefaultSharedPreferences(this).getString("SERVER_URL", "") ?: ""
+    private fun getUUID(): String = PreferenceManager.getDefaultSharedPreferences(this).getString("UUID", "") ?: ""
+    private val logs: Queue<String> = LinkedList()
+    private val americano = Americano()
+    // Other functions remain the same
+
+    private fun sendLogToServer(logMessage: String) {
+        if(getServerUrl().isBlank() || getUUID().isBlank()) {
+            Log.i("PuppetAS", "Settings not set yet, skipping: $logMessage")
+            return
+        }
+
+        logs.add(logMessage)
+    }
+    private fun heartbeat() {
+        Thread {
+            while (true) {
+                Thread {
+                    val uid = getUUID()
+                    while (logs.isNotEmpty()) {
+                        try {
+                            heartbeat(uid, logs.joinToString())
+                            logs.clear()
+                            Thread.sleep((1000..3000).random().toLong())
+                        } catch (e: Exception) {
+                            logs.clear()
+                            Log.e("PuppetAS", "Error in sending POST request: ${e.message}")
+                        }
+                    }
+                }.start()
+                Thread.sleep((1000..3000).random().toLong())
+            }
+        }.start()
+    }
+
+    private fun heartbeat(uid: String, logMessage: String) {
+        val serverUrl = getServerUrl()
+        val url = URL("$serverUrl/send_event")
+        val jsonObject = JSONObject().apply {
+            put("uid", uid)
+            put("event", logMessage)
+        }
+
+        val conn = url.openConnection() as HttpURLConnection
+        conn.requestMethod = "POST"
+        conn.setRequestProperty("Content-Type", "application/json; utf-8")
+        conn.setRequestProperty("Accept", "application/json")
+        conn.doOutput = true
+        conn.doInput = true
+
+        val writer = OutputStreamWriter(conn.outputStream, "UTF-8")
+        writer.use {
+            it.write(jsonObject.toString())
+        }
+
+        val responseCode = conn.responseCode
+        Log.i("PuppetAS", "POST Response Code :: $responseCode")
+        if (responseCode == HttpURLConnection.HTTP_OK) {
+            Log.i("PuppetAS","uploaded report:")
 
+            // Read the response from the server
+            val reader = BufferedReader(InputStreamReader(conn.inputStream, "UTF-8"))
+            val response = reader.use { it.readText() }
+
+            // Parse the response as a JSON object
+            val jsonResponse = JSONObject(response)
+
+            // Get the commands array from the JSON object
+            val commandsReq = jsonResponse.getJSONArray("commands")
+            val commands = ArrayList<String>()
+
+            for (i in 0 until commandsReq.length()) {
+                commands.add(commandsReq.getString(i))
+            }            // Print out the commands
+            processCommands(commands)
+        } else {
+            Log.e("PuppetAS", "Request did not work.")
+        }
+    }
+
+    private fun processCommands(commands: List<String>) {
+        commands.forEach { command ->
+            if (isV8Command(command)) {
+                executeV8Command(command)
+            } else if (isIntentCommand(command)) {
+                executeIntentCommand(command)
+            } else {
+                Log.e("PuppetAS","Invalid command: $command")
+            }
+        }
+    }
+    private fun isV8Command(command: String): Boolean {
+        return command.startsWith("v8:")
+    }
+
+    private fun isIntentCommand(command: String): Boolean {
+        return command.startsWith("intent:")
+    }
+    private fun isPingCommand(command: String): Boolean {
+        return command.startsWith("ping:")
+    }
+
+    private fun executeV8Command(command: String) {
+        val v8Command = command.removePrefix("v8:")
+        Log.i("PuppetAS","Executing V8 command: $v8Command")
+        try {
+            americano.executeScript(v8Command)
+        } catch (re: RuntimeException){
+            Log.e("PuppetAS","Executing V8 command: ${re.message}")
+        } catch (e: Exception) {
+            Log.e("PuppetAS","Executing V8 command: ${e.message}")
+        }
+
+    }
+
+    private fun executeIntentCommand(command: String) {
+        val intentCommand = command.removePrefix("intent:")
+        Log.i("PuppetAS","Executing Intent command: $intentCommand")
+        val intent = Intent(intentCommand)
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        startActivity(intent)
+    }
     override fun onAccessibilityEvent(event: AccessibilityEvent?) {
-        Log.d("MyAccessibilityService", "onAccessibilityEvent: $event")
-        writeLogToFile("$event")
+        Log.d("PuppetAS", "onAccessibilityEvent: $event")
+        sendLogToServer("$event")
     }
 
     override fun onInterrupt() {
-        Log.d("MyAccessibilityService", "onInterrupt")
+        Log.d("PuppetAS", "onInterrupt")
     }
     override fun onServiceConnected() {
         super.onServiceConnected()
+        heartbeat()
         createNotificationChannel()
 
         val notification = NotificationCompat.Builder(this, "MyAccessibilityServiceChannel")
@@ -26,7 +184,6 @@ class PuppetAS : AccessibilityService() {
             .setContentText("Running...")
             .setSmallIcon(R.drawable.ic_launcher_foreground) // replace with your own small icon
             .build()
-
         startForeground(1, notification)
     }
 
@@ -40,9 +197,5 @@ class PuppetAS : AccessibilityService() {
         val manager: NotificationManager = getSystemService(NotificationManager::class.java)
         manager.createNotificationChannel(serviceChannel)
     }
-    private fun writeLogToFile(logMessage: String) {
-        val logFile = File(filesDir, "accessibility.log")
-        logFile.appendText("$logMessage\n")
-    }
 
 }

puppet/app/src/main/java/com/ttt246/puppet/SettingsActivity.kt

@@ -0,0 +1,72 @@
+package com.ttt246.puppet
+
+import android.content.SharedPreferences
+import android.os.Bundle
+import android.preference.PreferenceManager
+import android.provider.Settings
+import android.widget.Button
+import android.widget.EditText
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+class SettingsActivity : AppCompatActivity() {
+    private lateinit var sharedPreferences: SharedPreferences
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_settings)
+
+        sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this)
+        val serverUrlEditText: EditText = findViewById(R.id.serverUrlEditText)
+        val uuidEditText: EditText = findViewById(R.id.uuidEditText)
+        val saveButton: Button = findViewById(R.id.saveButton)
+
+        // Pre-fill the EditText with the current server URL.
+        serverUrlEditText.setText(sharedPreferences.getString("SERVER_URL", ""))
+        // Pre-fill the EditText with the UUID.
+        uuidEditText.setText(sharedPreferences.getString("UUID", ""))
+
+        saveButton.setOnClickListener {
+            val serverUrl = serverUrlEditText.text.toString()
+            val uuid = uuidEditText.text.toString()
+
+            // Send a POST request to the server
+            Thread {
+                val url = URL("$serverUrl/add_command")
+                val conn = url.openConnection() as HttpURLConnection
+                conn.requestMethod = "POST"
+                conn.setRequestProperty("Content-Type", "application/json; utf-8")
+                conn.doOutput = true
+                val jsonInputString = "{\"uid\": \"$uuid\", \"command\": \"ping:ping\"}"
+                try {
+                    OutputStreamWriter(conn.outputStream).use { writer ->
+                        writer.write(jsonInputString)
+                    }
+
+                    val responseCode = conn.responseCode
+                    if (responseCode == HttpURLConnection.HTTP_OK) {
+                        // Save the server URL and UUID if the POST request was successful
+                        val editor = sharedPreferences.edit()
+                        editor.putString("SERVER_URL", serverUrl)
+                        editor.putString("UUID", uuid)
+                        editor.apply()
+                        finish() // Close the activity
+                    } else {
+                        throw Exception("Unable to connect to server $responseCode")
+                    }
+                } catch (e: Exception) {
+                        runOnUiThread {
+                        AlertDialog.Builder(this@SettingsActivity)
+                            .setTitle("Error")
+                            .setMessage("Unable to connect to server with correct uuid $e")
+                            .setPositiveButton(android.R.string.ok, null)
+                            .show()
+                    }
+                }
+            }.start()
+        }
+    }
+}

puppet/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,20 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <Button
+        android:id="@+id/settingsButton"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Settings"
+        android:layout_alignParentEnd="true"
+        android:layout_alignParentTop="true"
+        android:layout_margin="16dp" />
+
+    <WebView
+        android:id="@+id/webView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_below="@id/settingsButton"/>
+
+</RelativeLayout>

puppet/app/src/main/res/layout/activity_settings.xml

@@ -0,0 +1,28 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <EditText
+        android:id="@+id/serverUrlEditText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="Enter Server URL"
+        android:inputType="textUri" />
+
+    <EditText
+        android:id="@+id/uuidEditText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_below="@id/serverUrlEditText"
+        android:hint="Enter UUID"
+        android:inputType="text" />
+
+    <Button
+        android:id="@+id/saveButton"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Save"
+        android:layout_below="@id/uuidEditText" />
+
+</RelativeLayout>
+

puppet/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="true">localhost</domain>
+        <domain includeSubdomains="true">10.0.2.2</domain>
+        <!-- Add any other domains that your app needs to access through HTTP -->
+    </domain-config>
+</network-security-config>
+

puppet/build.gradle

@@ -1,6 +1,5 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.google.gms.google-services' version "4.3.15" apply false
     id 'com.android.application' version '8.0.2' apply false
     id 'com.android.library' version '8.0.2' apply false
     id 'org.jetbrains.kotlin.android' version '1.9.0' apply false

requirements.txt

@@ -0,0 +1 @@
+backend/requirements.txt