@elizaos/sweagent-root 2.0.0-alpha

package/python/tools/web_browser/lib/web_browser_utils.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import base64
+import functools
+import sys
+from enum import Enum
+from pathlib import Path
+
+import requests
+from flask import jsonify, request
+
+
+class ScreenshotMode(Enum):
+    SAVE = "save"  # saves screenshot to png file
+    PRINT = "print"  # prints base64 encoded screenshot to stdout
+
+
+def normalize_url(url: str) -> str:
+    # if starts with http:// or https://, return as is
+    # if starts with file://, return as is
+    # elif local file path exists, return as file://
+    # else: return as https://
+    if any(url.startswith(prefix) for prefix in ["http://", "https://", "file://"]):
+        return url
+    elif Path(url).exists():
+        return f"file://{Path(url).resolve()}"
+    else:
+        return "https://" + url
+
+
+def validate_request(*required_keys):
+    """Decorator to validate that all required keys are present in request JSON."""
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if not request.is_json:
+                return jsonify({"status": "error", "message": "Request must be JSON"})
+
+            request_data = request.get_json()
+            if not request_data:
+                return jsonify({"status": "error", "message": "Request body cannot be empty"})
+
+            missing_keys = [key for key in required_keys if key not in request_data]
+            if missing_keys:
+                return jsonify({"status": "error", "message": f"Missing required fields: {', '.join(missing_keys)}"})
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def catch_error(func):
+    """Decorator to catch exceptions and return them as JSON."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)})
+
+    return wrapper
+
+
+def _print_error(message, error_type="ERROR"):
+    """Print error message in a normalized format."""
+    print(f"{error_type}: {message}", file=sys.stderr)
+
+
+def _format_metadata_info(response):
+    """Format metadata information from API response for display."""
+    if "metadata" not in response or not response["metadata"]:
+        return ""
+    return "\n".join(f"{key}: {value}" for key, value in response["metadata"].items())
+
+
+def send_request(port, endpoint, method="GET", data=None):
+    url = f"http://localhost:{port}/{endpoint}"
+    if method == "GET":
+        response = requests.get(url)
+    else:
+        response = requests.post(url, json=data)
+    if response.status_code != 200:
+        _print_error(f"Internal error communicating with backend: {response.text}", "INTERNAL ERROR")
+        return None
+    data = response.json()
+    if data["status"] == "error":
+        metadata_info = _format_metadata_info(data)
+        error_message = data["message"]
+        _print_error(f"ACTION ERROR:\n{error_message}")
+        if metadata_info:
+            print(f"\nMETADATA:\n{metadata_info}", file=sys.stderr)
+        return None
+    return data
+
+
+def _print_response_with_metadata(response):
+    """Print response message with formatted metadata information."""
+    message = response.get("message", "")
+    metadata_info = _format_metadata_info(response)
+    print(f"ACTION RESPONSE:\n{message}")
+
+    if metadata_info:
+        print(f"\nMETADATA:\n{metadata_info}")
+
+
+def _handle_screenshot(screenshot_data, mode):
+    """Handle screenshot data according to the specified mode"""
+    if mode == ScreenshotMode.SAVE:
+        path = Path("latest_screenshot.png")
+        path.write_bytes(base64.b64decode(screenshot_data))
+        print(f"![Screenshot]({path})")
+    elif mode == ScreenshotMode.PRINT:
+        print(f"![Screenshot](data:image/png;base64,{screenshot_data})")
+    else:
+        message = f"Invalid screenshot mode: {mode}"
+        raise ValueError(message)
+
+
+def _autosave_screenshot_from_response(response, mode):
+    """Handle screenshot from response data according to the specified mode"""
+    if "screenshot" in response:
+        _handle_screenshot(response["screenshot"], mode)

package/python/tools/web_browser/test_console.html

@@ -0,0 +1 @@
+<script>console.log("Hello from console!"); console.error("Test error"); console.warn("Test warning");</script><h1>Test Page</h1>

package/python/tools/windowed/bin/_state

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+
+import json
+import os
+from pathlib import Path
+
+from registry import registry  # type: ignore
+
+
+def main():
+    state_path = Path("/root/state.json")
+
+    if state_path.exists():
+        state = json.loads(state_path.read_text())
+    else:
+        state = {}
+
+    current_file = registry.get("CURRENT_FILE")
+    open_file = "n/a" if not current_file else str(Path(current_file).resolve())
+    state["open_file"] = open_file
+    state["working_dir"] = os.getcwd()
+    state_path.write_text(json.dumps(state))
+
+if __name__ == "__main__":
+    main()

package/python/tools/windowed/bin/create

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from windowed_file import WindowedFile  # type: ignore
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: create <filename>")
+        sys.exit(1)
+
+    path = Path(sys.argv[1])
+    if not path.parent.is_dir():
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.exists():
+        print(f"Warning: File '{path}' already exists.")
+        sys.exit(1)
+
+    path.touch()
+
+    wfile = WindowedFile(path=path)
+    wfile.first_line = 0
+    wfile.print_window()
+
+
+if __name__ == "__main__":
+    main()

package/python/tools/windowed/bin/goto

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+import sys
+from typing import List
+
+from windowed_file import WindowedFile  # type: ignore
+
+
+def main(args: List[str]) -> int:
+    if len(args) > 1:
+        print("goto allows only one line number at a time.")
+        return 1
+
+    if not args:
+        print("Usage: goto <line>")
+        return 1
+
+    try:
+        line_number = int(args[0])
+    except ValueError:
+        print("Usage: goto <line>")
+        print("Error: <line> must be a number")
+        return 1
+
+    wf = WindowedFile()
+
+    if line_number > wf.n_lines:
+        print(f"Error: <line> must be less than or equal to {wf.n_lines}")
+        return 1
+
+    # Convert from 1-based line numbers (user input) to 0-based (internal representation)
+    wf.goto(line_number - 1, mode="top")
+    wf.print_window()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/python/tools/windowed/bin/open

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+import sys
+from typing import Optional
+
+from windowed_file import FileNotOpened, WindowedFile  # type: ignore
+
+
+def main(path: Optional[str] = None, line_number: Optional[str] = None) -> None:
+    if path is None:
+        try:
+            WindowedFile(exit_on_exception=False).print_window()
+            # If this passes, then there was already a file open and we just show it again
+            sys.exit(0)
+        except FileNotOpened:
+            print('Usage: open "<file>"')
+            sys.exit(1)
+
+    assert path is not None
+
+    wf = WindowedFile(path=path)
+
+    if line_number is not None:
+        try:
+            line_num = int(line_number)
+        except ValueError:
+            print('Usage: open "<file>" [<line_number>]')
+            print("Error: <line_number> must be a number")
+            sys.exit(1)
+        if line_num > wf.n_lines:
+            print(f"Warning: <line_number> ({line_num}) is greater than the number of lines in the file ({wf.n_lines})")
+            print(f"Warning: Setting <line_number> to {wf.n_lines}")
+            line_num = wf.n_lines
+        elif line_num < 1:
+            print(f"Warning: <line_number> ({line_num}) is less than 1")
+            print("Warning: Setting <line_number> to 1")
+            line_num = 1
+    else:
+        # Default to middle of window if no line number provided
+        line_num = wf.first_line
+
+    wf.goto(line_num - 1, mode="top")
+    wf.print_window()
+
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    file_path = args[0] if args else None
+    line_number = args[1] if len(args) > 1 else None
+    main(file_path, line_number)

package/python/tools/windowed/bin/scroll_down

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+from windowed_file import WindowedFile  # type: ignore
+
+
+def main():
+    wf = WindowedFile()
+    wf.scroll(wf.window)
+    wf.print_window()
+
+if __name__ == "__main__":
+    main()

package/python/tools/windowed/bin/scroll_up

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+
+from windowed_file import WindowedFile  # type: ignore
+
+
+def main():
+    wf = WindowedFile()
+    wf.scroll(-wf.window)
+    wf.print_window()
+
+
+if __name__ == "__main__":
+    main()

package/python/tools/windowed/config.yaml

@@ -0,0 +1,38 @@
+tools:
+  goto:
+    signature: "goto <line_number>"
+    docstring: "moves the window to show <line_number>"
+    arguments:
+      - name: line_number
+        type: integer
+        description: "the line number to move the window to"
+        required: true
+  open:
+    signature: 'open "<path>" [<line_number>]'
+    docstring: "opens the file at the given path in the editor. If line_number is provided, the window will be move to include that line"
+    arguments:
+      - name: path
+        type: string
+        description: "the path to the file to open"
+        required: true
+      - name: line_number
+        type: integer
+        description: "the line number to move the window to (if not provided, the window will start at the top of the file)"
+        required: false
+  create:
+    signature: "create <filename>"
+    docstring: "creates and opens a new file with the given name"
+    arguments:
+      - name: filename
+        type: string
+        description: "the name of the file to create"
+        required: true
+  scroll_up:
+    signature: "scroll_up"
+    docstring: "moves the window up {WINDOW} lines"
+    arguments: []
+  scroll_down:
+    signature: "scroll_down"
+    docstring: "moves the window down {WINDOW} lines"
+    arguments: []
+state_command: "_state"

package/python/tools/windowed/install.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+# script_dir=$(dirname "$(readlink -f "$0")")
+bundle_dir=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+export PYTHONPATH="$bundle_dir/lib":$PYTHONPATH
+
+# Write default environment variables into the environment storage
+_write_env "WINDOW" "${WINDOW:-100}"
+_write_env "OVERLAP" "${OVERLAP:-2}"
+_write_env "FIRST_LINE" "${FIRST_LINE:-0}"
+_write_env "CURRENT_FILE" "${CURRENT_FILE:-}"
+
+# install jq
+# apt-get update && apt-get install -y jq

package/python/tools/windowed/lib/flake8_utils.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+
+"""This helper command is used to parse and print flake8 output."""
+
+import subprocess
+from pathlib import Path
+
+try:
+    from sweagent import TOOLS_DIR
+except ImportError:
+    pass
+else:
+    import sys
+
+    default_lib = TOOLS_DIR / "windowed" / "lib"
+    assert default_lib.is_dir()
+    sys.path.append(str(default_lib))
+    sys.path.append(str(TOOLS_DIR / "registry" / "lib"))
+
+from registry import registry
+
+
+class Flake8Error:
+    """A class to represent a single flake8 error"""
+
+    def __init__(self, filename: str, line_number: int, col_number: int, problem: str):
+        self.filename = filename
+        self.line_number = line_number
+        self.col_number = col_number
+        self.problem = problem
+
+    @classmethod
+    def from_line(cls, line: str):
+        try:
+            prefix, _sep, problem = line.partition(": ")
+            filename, line_number, col_number = prefix.split(":")
+        except (ValueError, IndexError) as e:
+            msg = f"Invalid flake8 error line: {line}"
+            raise ValueError(msg) from e
+        return cls(filename, int(line_number), int(col_number), problem)
+
+    def __eq__(self, other):
+        if not isinstance(other, Flake8Error):
+            return NotImplemented
+        return (
+            self.filename == other.filename
+            and self.line_number == other.line_number
+            and self.col_number == other.col_number
+            and self.problem == other.problem
+        )
+
+    def __repr__(self):
+        return f"Flake8Error(filename={self.filename}, line_number={self.line_number}, col_number={self.col_number}, problem={self.problem})"
+
+
+def _update_previous_errors(
+    previous_errors: list[Flake8Error],
+    replacement_window: tuple[int, int],
+    replacement_n_lines: int,
+) -> list[Flake8Error]:
+    """Update the line numbers of the previous errors to what they would be after the edit window.
+    This is a helper function for `_filter_previous_errors`.
+
+    All previous errors that are inside of the edit window should not be ignored,
+    so they are removed from the previous errors list.
+
+    Args:
+        previous_errors: list of errors with old line numbers
+        replacement_window: the window of the edit/lines that will be replaced
+        replacement_n_lines: the number of lines that will be used to replace the text
+
+    Returns:
+        list of errors with updated line numbers
+    """
+    updated = []
+    lines_added = replacement_n_lines - (replacement_window[1] - replacement_window[0] + 1)
+    for error in previous_errors:
+        if error.line_number < replacement_window[0]:
+            # no need to adjust the line number
+            updated.append(error)
+            continue
+        if replacement_window[0] <= error.line_number <= replacement_window[1]:
+            # The error is within the edit window, so let's not ignore it
+            # either way (we wouldn't know how to adjust the line number anyway)
+            continue
+        # We're out of the edit window, so we need to adjust the line number
+        updated.append(Flake8Error(error.filename, error.line_number + lines_added, error.col_number, error.problem))
+    return updated
+
+
+def format_flake8_output(
+    input_string: str,
+    show_line_numbers: bool = False,
+    *,
+    previous_errors_string: str = "",
+    replacement_window: tuple[int, int] | None = None,
+    replacement_n_lines: int | None = None,
+) -> str:
+    """Filter flake8 output for previous errors and print it for a given file.
+
+    Args:
+        input_string: The flake8 output as a string
+        show_line_numbers: Whether to show line numbers in the output
+        previous_errors_string: The previous errors as a string
+        replacement_window: The window of the edit (lines that will be replaced)
+        replacement_n_lines: The number of lines used to replace the text
+
+    Returns:
+        The filtered flake8 output as a string
+    """
+    errors = [Flake8Error.from_line(line.strip()) for line in input_string.split("\n") if line.strip()]
+    # print(f"New errors before filtering: {errors=}")
+    lines = []
+    if previous_errors_string:
+        assert replacement_window is not None
+        assert replacement_n_lines is not None
+        previous_errors = [
+            Flake8Error.from_line(line.strip()) for line in previous_errors_string.split("\n") if line.strip()
+        ]
+        # print(f"Previous errors before updating: {previous_errors=}")
+        previous_errors = _update_previous_errors(previous_errors, replacement_window, replacement_n_lines)
+        # print(f"Previous errors after updating: {previous_errors=}")
+        errors = [error for error in errors if error not in previous_errors]
+        # Sometimes new errors appear above the replacement window that were 'shadowed' by the previous errors
+        # they still clearly aren't caused by the edit.
+        errors = [error for error in errors if error.line_number >= replacement_window[0]]
+        # print(f"New errors after filtering: {errors=}")
+    for error in errors:
+        if not show_line_numbers:
+            lines.append(f"- {error.problem}")
+        else:
+            lines.append(f"- line {error.line_number} col {error.col_number}: {error.problem}")
+    return "\n".join(lines)
+
+
+def flake8(file_path: str) -> str:
+    """Run flake8 on a given file and return the output as a string"""
+    if Path(file_path).suffix != ".py":
+        return ""
+    cmd = registry.get("LINT_COMMAND", "flake8 --isolated --select=F821,F822,F831,E111,E112,E113,E999,E902 {file_path}")
+    out = subprocess.run(
+        cmd.format(file_path=file_path),
+        shell=True,
+        capture_output=True,
+        text=True,
+    )
+    return out.stdout