llms-py 3.0.0b7__py3-none-any.whl → 3.0.0b8__py3-none-any.whl

llms/extensions/core_tools/__init__.py

@@ -3,11 +3,13 @@ Core System Tools providing essential file operations, memory persistence, math
 """
 
 import ast
+import contextlib
 import glob
 import json
 import math
 import operator
 import os
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -15,6 +17,10 @@ from datetime import datetime, timezone
 from statistics import mean, median, stdev, variance
 from typing import Any, Dict, List, Optional
 
+from aiohttp import web
+
+g_ctx = None
+
 # -----------------------------
 # In-memory storage (replace later)
 # -----------------------------
@@ -179,6 +185,26 @@ def glob_paths(
 # -----------------------------
 
 
+def get_calculator_functions():
+    # 2. Define allowed math functions and constants
+    allowed_functions = {
+        "mod": operator.mod,
+        "mean": mean,
+        "median": median,
+        "stdev": stdev,
+        "variance": variance,
+        "abs": abs,
+        "min": min,
+        "max": max,
+        "sum": sum,
+        "round": round,
+    }
+    allowed_functions.update(
+        {name: getattr(math, name) for name in dir(math) if not name.startswith("_") and name not in allowed_functions}
+    )
+    return allowed_functions
+
+
 def calc(expression: str) -> str:
     """Evaluate a mathematical expression with boolean operations"""
     # 1. Define allowed operators
@@ -204,68 +230,87 @@ def calc(expression: str) -> str:
     }
 
     # 2. Define allowed math functions and constants
-    allowed_functions = {name: getattr(math, name) for name in dir(math) if not name.startswith("_")}
-    allowed_functions.update(
-        {
-            "mod": operator.mod,
-            "mean": mean,
-            "median": median,
-            "stdev": stdev,
-            "variance": variance,
-            "abs": abs,
-            "min": min,
-            "max": max,
-            "sum": sum,
-            "round": round,
-        }
-    )
+    allowed_functions = get_calculator_functions()
+
+    def eval_node(node, context=None):
+        if context is None:
+            context = {}
 
-    def eval_node(node):
         if isinstance(node, ast.Constant):  # Numbers and booleans
             return node.value
         elif isinstance(node, ast.BinOp):  # Binary Ops (1 + 2)
-            return operators[type(node.op)](eval_node(node.left), eval_node(node.right))
+            return operators[type(node.op)](eval_node(node.left, context), eval_node(node.right, context))
         elif isinstance(node, ast.UnaryOp):  # Unary Ops (-5, not True)
-            return operators[type(node.op)](eval_node(node.operand))
+            return operators[type(node.op)](eval_node(node.operand, context))
         elif isinstance(node, ast.Compare):  # Comparison (5 > 3)
-            left = eval_node(node.left)
+            left = eval_node(node.left, context)
             for op, comparator in zip(node.ops, node.comparators):
-                right = eval_node(comparator)
+                right = eval_node(comparator, context)
                 if not operators[type(op)](left, right):
                     return False
                 left = right
             return True
         elif isinstance(node, ast.BoolOp):  # Boolean operations (True and False, True or False)
-            op = operators[type(node.op)]
             if isinstance(node.op, ast.And):
                 # Short-circuit evaluation for 'and'
                 result = True
                 for value in node.values:
-                    result = eval_node(value)
+                    result = eval_node(value, context)
                     if not result:
                         return False
                 return result
             elif isinstance(node.op, ast.Or):
                 # Short-circuit evaluation for 'or'
                 for value in node.values:
-                    result = eval_node(value)
+                    result = eval_node(value, context)
                     if result:
                         return True
                 return False
         elif isinstance(node, ast.Call):  # Function calls (sqrt(16))
             func_name = node.func.id
             if func_name in allowed_functions:
-                args = [eval_node(arg) for arg in node.args]
+                args = [eval_node(arg, context) for arg in node.args]
                 return allowed_functions[func_name](*args)
+            if func_name == "range":
+                args = [eval_node(arg, context) for arg in node.args]
+                return range(*args)
             raise NameError(f"Function '{func_name}' is not allowed.")
-        elif isinstance(node, ast.Name):  # Constants (pi, e, True, False)
+        elif isinstance(node, ast.Name):  # Constants (pi, e, True, False) or context variables
+            if node.id in context:
+                return context[node.id]
             if node.id in allowed_functions:
                 return allowed_functions[node.id]
             elif node.id in ("True", "False"):
                 return node.id == "True"
             raise NameError(f"Variable '{node.id}' is not defined.")
         elif isinstance(node, ast.List):  # List literals [1, 2, 3]
-            return [eval_node(item) for item in node.elts]
+            return [eval_node(item, context) for item in node.elts]
+        elif isinstance(node, ast.ListComp):  # List comprehensions [x*2 for x in [1,2,3]]
+            result = []
+            generators = node.generators
+            if len(generators) != 1:
+                raise ValueError("Only single-generator list comprehensions are supported")
+            gen = generators[0]
+            if not isinstance(gen.target, ast.Name):
+                raise ValueError("Only simple name targets in list comprehensions are supported")
+
+            target_name = gen.target.id
+            iterable = eval_node(gen.iter, context)
+
+            for item in iterable:
+                new_context = context.copy()
+                new_context[target_name] = item
+
+                # Check ifs
+                include = True
+                for if_node in gen.ifs:
+                    if not eval_node(if_node, new_context):
+                        include = False
+                        break
+
+                if include:
+                    result.append(eval_node(node.elt, new_context))
+            return result
         else:
             raise TypeError(f"Unsupported operation: {type(node).__name__}")
 
@@ -274,13 +319,19 @@ def calc(expression: str) -> str:
 
     # Parse and evaluate
     node = ast.parse(expression, mode="eval").body
-    return eval_node(node)
+    ret = eval_node(node)
+    g_ctx.dbg(f"calc ({expression}) = {ret}")
+    return ret
 
 
 # -----------------------------
-# Python execution tool
+# code execution tools
 # -----------------------------
 
+mem_limit = 8589934592  # Max virtual memory 8GB
+cpu_time_limit = 5  # Max CPU time 5 seconds
+resource_limits = f"ulimit -t {cpu_time_limit}; ulimit -v {mem_limit};"
+
 
 def run_python(code: str) -> Dict[str, Any]:
     """
@@ -293,16 +344,141 @@ def run_python(code: str) -> Dict[str, Any]:
         with open(script_path, "w", encoding="utf-8") as f:
             f.write(code)
 
-        # Construct command with resource limits
-        # ulimit -t 5: Max CPU time 5 seconds
-        # ulimit -v 1048576: Max virtual memory 1GB
-        cmd = f"ulimit -t 5; ulimit -v 1048576; {sys.executable} script.py"
+        cmd = f"{resource_limits} {sys.executable} script.py"
+
+        run_as = os.environ.get("LLMS_RUN_AS")
+        if run_as:
+            # Grant access to temp_dir
+            with contextlib.suppress(Exception):
+                os.chmod(temp_dir, 0o777)
+            cmd = f"sudo -u {run_as} bash -c '{cmd}'"
 
         try:
             # Run with restricted environment
             # We keep PATH to find basic tools if needed, but remove sensitive vars
             clean_env = {"PATH": os.environ.get("PATH", "")}
 
+            g_ctx.dbg(f"run_python ({temp_dir}): {cmd}\n{code}")
+            result = subprocess.run(
+                ["bash", "-c", cmd], cwd=temp_dir, env=clean_env, capture_output=True, text=True, timeout=10
+            )
+            return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+        except subprocess.TimeoutExpired:
+            return {"stdout": "", "stderr": "Execution timed out", "returncode": -1}
+        except Exception as e:
+            return {"stdout": "", "stderr": f"Error: {e}", "returncode": -1}
+
+
+def run_javascript(code: str) -> Dict[str, Any]:
+    """
+    Execute JavaScript code in a temporary sandboxed environment using bun or node.
+    """
+    # Check for available runtime
+    runtime = shutil.which("bun") or shutil.which("node")
+    if not runtime:
+        return {"stdout": "", "stderr": "Error: Neither 'bun' nor 'node' is available on the system.", "returncode": -1}
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        script_path = os.path.join(temp_dir, "script.js")
+
+        with open(script_path, "w", encoding="utf-8") as f:
+            f.write(code)
+
+        cmd = f"{resource_limits} {runtime} script.js"
+
+        run_as = os.environ.get("LLMS_RUN_AS")
+        if run_as:
+            with contextlib.suppress(Exception):
+                os.chmod(temp_dir, 0o777)
+            cmd = f"sudo -u {run_as} bash -c '{cmd}'"
+
+        try:
+            # Run with restricted environment
+            clean_env = {"PATH": os.environ.get("PATH", "")}
+
+            g_ctx.dbg(f"run_javascript ({temp_dir}): {cmd}\n{code}")
+            result = subprocess.run(
+                ["bash", "-c", cmd], cwd=temp_dir, env=clean_env, capture_output=True, text=True, timeout=10
+            )
+            return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+        except subprocess.TimeoutExpired:
+            return {"stdout": "", "stderr": "Execution timed out", "returncode": -1}
+        except Exception as e:
+            return {"stdout": "", "stderr": f"Error: {e}", "returncode": -1}
+
+
+def run_typescript(code: str) -> Dict[str, Any]:
+    """
+    Execute TypeScript code in a temporary sandboxed environment using bun or node.
+    """
+    # Check for available runtime
+    runtime = shutil.which("bun") or shutil.which("node")
+    if not runtime:
+        return {"stdout": "", "stderr": "Error: Neither 'bun' nor 'node' is available on the system.", "returncode": -1}
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        script_path = os.path.join(temp_dir, "script.ts")
+
+        with open(script_path, "w", encoding="utf-8") as f:
+            f.write(code)
+
+        cmd = f"{resource_limits} {runtime} script.ts"
+
+        run_as = os.environ.get("LLMS_RUN_AS")
+        if run_as:
+            with contextlib.suppress(Exception):
+                os.chmod(temp_dir, 0o777)
+            cmd = f"sudo -u {run_as} bash -c '{cmd}'"
+
+        try:
+            # Run with restricted environment
+            clean_env = {"PATH": os.environ.get("PATH", "")}
+
+            g_ctx.dbg(f"run_typescript ({temp_dir}): {cmd}\n{code}")
+            result = subprocess.run(
+                ["bash", "-c", cmd], cwd=temp_dir, env=clean_env, capture_output=True, text=True, timeout=10
+            )
+            return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+        except subprocess.TimeoutExpired:
+            return {"stdout": "", "stderr": "Execution timed out", "returncode": -1}
+        except Exception as e:
+            return {"stdout": "", "stderr": f"Error: {e}", "returncode": -1}
+
+
+def run_csharp(code: str) -> Dict[str, Any]:
+    """
+    Execute C# code in a temporary sandboxed environment using dotnet.
+    """
+    # Check for available runtime
+    runtime = shutil.which("dotnet")
+    if not runtime:
+        return {"stdout": "", "stderr": "Error: 'dotnet' is not available on the system.", "returncode": -1}
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        script_path = os.path.join(temp_dir, "script.cs")
+
+        # Ensure we just have the code, user might pass it without wrapping class if it's top-level statements
+        with open(script_path, "w", encoding="utf-8") as f:
+            f.write(code)
+
+        # Note: 'dotnet run script.cs' is the command as per user request for .NET 10
+        cmd = f"{resource_limits} {runtime} run script.cs"
+
+        run_as = os.environ.get("LLMS_RUN_AS")
+        if run_as:
+            with contextlib.suppress(Exception):
+                os.chmod(temp_dir, 0o777)
+            # For dotnet, we need to set HOME and DOTNET_CLI_HOME to temp_dir for write access
+            cmd = f"sudo -u {run_as} env HOME={temp_dir} DOTNET_CLI_HOME={temp_dir} bash -c '{cmd}'"
+
+        try:
+            # Run with restricted environment
+            clean_env = {"PATH": os.environ.get("PATH", "")}
+
+            # Dotnet might need some ENV vars to work correctly, usually DOTNET_CLI_HOME or similar if strictly sandboxed
+            # But we are keeping PATH, hopefully commonly needed vars are there or default works.
+            # We might want to pass more env vars if it fails.
+            g_ctx.dbg(f"run_csharp ({temp_dir}): {cmd}\n{code}")
             result = subprocess.run(
                 ["bash", "-c", cmd], cwd=temp_dir, env=clean_env, capture_output=True, text=True, timeout=10
             )
@@ -342,6 +518,8 @@ def get_current_time(tz_name: Optional[str] = None) -> str:
 
 
 def install(ctx):
+    global g_ctx
+    g_ctx = ctx
     # Examples of registering tools using automatic definition generation
     ctx.register_tool(memory_read)
     ctx.register_tool(memory_write)
@@ -352,7 +530,69 @@ def install(ctx):
     ctx.register_tool(glob_paths)
     ctx.register_tool(calc)
     ctx.register_tool(run_python)
+    ctx.register_tool(run_typescript)
+    ctx.register_tool(run_javascript)
+    ctx.register_tool(run_csharp)
     ctx.register_tool(get_current_time)
 
+    def exec_language(language: str, code: str) -> Dict[str, Any]:
+        if language == "python":
+            return run_python(code)
+        elif language == "typescript":
+            return run_typescript(code)
+        elif language == "javascript":
+            return run_javascript(code)
+        elif language == "csharp":
+            return run_csharp(code)
+        else:
+            return {"stdout": "", "stderr": "Error: Invalid language", "returncode": -1}
+
+    async def run_code(request):
+        language = request.match_info["language"]
+        code = await request.text()
+        try:
+            result = exec_language(language, code)
+        except Exception as e:
+            result = {"stdout": "", "stderr": str(e), "returncode": -1}
+        return web.json_response(result)
+
+    ctx.add_post("code/{language}/run", run_code)
+
+    async def get_calculator_features(request):
+        operators = ["+", "-", "*", "/", "%", "^", "==", "!=", "<", "<=", ">", ">=", "and", "or", "not"]
+        operators = [f" {op} " for op in operators]
+        constants = ["pi", "e", "inf", "tau", "nan"]
+        functions = [f for f in get_calculator_functions() if f not in constants]
+        return web.json_response(
+            {
+                "numbers": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+                "constants": constants,
+                "operators": operators,
+                "functions": sorted(functions),
+            }
+        )
+
+    ctx.add_get("calc", get_calculator_features)
+
+    async def run_calc(request):
+        code = await request.text()
+        result = calc(code)
+        return web.json_response({"result": result})
+
+    ctx.add_post("calc", run_calc)
+
+    ctx.add_index_footer(
+        f"""
+        <link rel="stylesheet" href="{ctx.ext_prefix}/codemirror/lib/codemirror.css">
+        <link rel="stylesheet" href="{ctx.ext_prefix}/codemirror/theme/mocha.css">
+        <script src="{ctx.ext_prefix}/codemirror/lib/codemirror.js"></script>
+        <script src="{ctx.ext_prefix}/codemirror/mode/clike/clike.js"></script>
+        <script src="{ctx.ext_prefix}/codemirror/mode/javascript/javascript.js"></script>
+        <script src="{ctx.ext_prefix}/codemirror/mode/python/python.js"></script>
+        <script src="{ctx.ext_prefix}/codemirror/addon/edit/matchbrackets.js"></script>
+        <script src="{ctx.ext_prefix}/codemirror/addon/selection/active-line.js"></script>
+        """
+    )
+
 
 __install__ = install

llms/extensions/core_tools/ui/codemirror/addon/edit/closebrackets.js

@@ -0,0 +1,201 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/5/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var defaults = {
+    pairs: "()[]{}''\"\"",
+    closeBefore: ")]}'\":;>",
+    triples: "",
+    explode: "[]{}"
+  };
+
+  var Pos = CodeMirror.Pos;
+
+  CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.removeKeyMap(keyMap);
+      cm.state.closeBrackets = null;
+    }
+    if (val) {
+      ensureBound(getOption(val, "pairs"))
+      cm.state.closeBrackets = val;
+      cm.addKeyMap(keyMap);
+    }
+  });
+
+  function getOption(conf, name) {
+    if (name == "pairs" && typeof conf == "string") return conf;
+    if (typeof conf == "object" && conf[name] != null) return conf[name];
+    return defaults[name];
+  }
+
+  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};
+  function ensureBound(chars) {
+    for (var i = 0; i < chars.length; i++) {
+      var ch = chars.charAt(i), key = "'" + ch + "'"
+      if (!keyMap[key]) keyMap[key] = handler(ch)
+    }
+  }
+  ensureBound(defaults.pairs + "`")
+
+  function handler(ch) {
+    return function(cm) { return handleChar(cm, ch); };
+  }
+
+  function getConfig(cm) {
+    var deflt = cm.state.closeBrackets;
+    if (!deflt || deflt.override) return deflt;
+    var mode = cm.getModeAt(cm.getCursor());
+    return mode.closeBrackets || deflt;
+  }
+
+  function handleBackspace(cm) {
+    var conf = getConfig(cm);
+    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var pairs = getOption(conf, "pairs");
+    var ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var around = charsAround(cm, ranges[i].head);
+      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+    }
+    for (var i = ranges.length - 1; i >= 0; i--) {
+      var cur = ranges[i].head;
+      cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), "+delete");
+    }
+  }
+
+  function handleEnter(cm) {
+    var conf = getConfig(cm);
+    var explode = conf && getOption(conf, "explode");
+    if (!explode || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var around = charsAround(cm, ranges[i].head);
+      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+    }
+    cm.operation(function() {
+      var linesep = cm.lineSeparator() || "\n";
+      cm.replaceSelection(linesep + linesep, null);
+      moveSel(cm, -1)
+      ranges = cm.listSelections();
+      for (var i = 0; i < ranges.length; i++) {
+        var line = ranges[i].head.line;
+        cm.indentLine(line, null, true);
+        cm.indentLine(line + 1, null, true);
+      }
+    });
+  }
+
+  function moveSel(cm, dir) {
+    var newRanges = [], ranges = cm.listSelections(), primary = 0
+    for (var i = 0; i < ranges.length; i++) {
+      var range = ranges[i]
+      if (range.head == cm.getCursor()) primary = i
+      var pos = range.head.ch || dir > 0 ? {line: range.head.line, ch: range.head.ch + dir} : {line: range.head.line - 1}
+      newRanges.push({anchor: pos, head: pos})
+    }
+    cm.setSelections(newRanges, primary)
+  }
+
+  function contractSelection(sel) {
+    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;
+    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),
+            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};
+  }
+
+  function handleChar(cm, ch) {
+    var conf = getConfig(cm);
+    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var pairs = getOption(conf, "pairs");
+    var pos = pairs.indexOf(ch);
+    if (pos == -1) return CodeMirror.Pass;
+
+    var closeBefore = getOption(conf,"closeBefore");
+
+    var triples = getOption(conf, "triples");
+
+    var identical = pairs.charAt(pos + 1) == ch;
+    var ranges = cm.listSelections();
+    var opening = pos % 2 == 0;
+
+    var type;
+    for (var i = 0; i < ranges.length; i++) {
+      var range = ranges[i], cur = range.head, curType;
+      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
+      if (opening && !range.empty()) {
+        curType = "surround";
+      } else if ((identical || !opening) && next == ch) {
+        if (identical && stringStartsAfter(cm, cur))
+          curType = "both";
+        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)
+          curType = "skipThree";
+        else
+          curType = "skip";
+      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&
+                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch) {
+        if (cur.ch > 2 && /\bstring/.test(cm.getTokenTypeAt(Pos(cur.line, cur.ch - 2)))) return CodeMirror.Pass;
+        curType = "addFour";
+      } else if (identical) {
+        var prev = cur.ch == 0 ? " " : cm.getRange(Pos(cur.line, cur.ch - 1), cur)
+        if (!CodeMirror.isWordChar(next) && prev != ch && !CodeMirror.isWordChar(prev)) curType = "both";
+        else return CodeMirror.Pass;
+      } else if (opening && (next.length === 0 || /\s/.test(next) || closeBefore.indexOf(next) > -1)) {
+        curType = "both";
+      } else {
+        return CodeMirror.Pass;
+      }
+      if (!type) type = curType;
+      else if (type != curType) return CodeMirror.Pass;
+    }
+
+    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;
+    var right = pos % 2 ? ch : pairs.charAt(pos + 1);
+    cm.operation(function() {
+      if (type == "skip") {
+        moveSel(cm, 1)
+      } else if (type == "skipThree") {
+        moveSel(cm, 3)
+      } else if (type == "surround") {
+        var sels = cm.getSelections();
+        for (var i = 0; i < sels.length; i++)
+          sels[i] = left + sels[i] + right;
+        cm.replaceSelections(sels, "around");
+        sels = cm.listSelections().slice();
+        for (var i = 0; i < sels.length; i++)
+          sels[i] = contractSelection(sels[i]);
+        cm.setSelections(sels);
+      } else if (type == "both") {
+        cm.replaceSelection(left + right, null);
+        cm.triggerElectric(left + right);
+        moveSel(cm, -1)
+      } else if (type == "addFour") {
+        cm.replaceSelection(left + left + left + left, "before");
+        moveSel(cm, 1)
+      }
+    });
+  }
+
+  function charsAround(cm, pos) {
+    var str = cm.getRange(Pos(pos.line, pos.ch - 1),
+                          Pos(pos.line, pos.ch + 1));
+    return str.length == 2 ? str : null;
+  }
+
+  function stringStartsAfter(cm, pos) {
+    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))
+    return /\bstring/.test(token.type) && token.start == pos.ch &&
+      (pos.ch == 0 || !/\bstring/.test(cm.getTokenTypeAt(pos)))
+  }
+});