runcell 0.1.15a10__py3-none-any.whl → 0.1.16__py3-none-any.whl

d5m_ai/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.1.15a10'
+__version__ = VERSION = '0.1.16'

d5m_ai/agent/proxy_handler.py

@@ -13,6 +13,7 @@ The jupyter backend now serves as:
 import asyncio
 import json
 import os
+import re
 import ssl
 import uuid
 import websockets
@@ -76,18 +77,28 @@ class AIJLAgentProxyHandler(WebSocketHandler):
 
     def _get_user_token(self) -> Optional[str]:
         """
-        Get user token from local file (saved during OAuth flow).
+        Get user token from query param (preferred for remote/ephemeral servers) or local file.
         
         Returns:
             User token if found, None otherwise
         """
-        # Use existing token handler utility
+        token_param = None
+        try:
+            token_param = self.get_query_argument("token", default=None)
+        except Exception:
+            token_param = None
+
+        if token_param and token_param.startswith("eyJ") and token_param.count(".") == 2:
+            print("[PROXY] ✅ Found user token in WebSocket query param")
+            return token_param
+
         token = get_current_user_token_string()
         if token:
-            print(f"[PROXY] ✅ Found user token")
-        else:
-            print("[PROXY] ❌ No user token found")
-        return token
+            print("[PROXY] ✅ Found user token in local file")
+            return token
+
+        print("[PROXY] ❌ No user token found")
+        return None
 
     def _is_remote_connection_closed(self) -> bool:
         """Check if the remote WebSocket connection is closed."""
@@ -157,7 +168,8 @@ class AIJLAgentProxyHandler(WebSocketHandler):
                         separator = "&" if "?" in connection_url else "?"
                         connection_url = f"{connection_url}{separator}{'&'.join(params)}"
                     
-                    print(f"[PROXY] Remote URL: {connection_url}")
+                    redacted_url = re.sub(r"(token=)[^&]+", r"\1<redacted>", connection_url)
+                    print(f"[PROXY] Remote URL: {redacted_url}")
                     
                     # Only create SSL context for wss:// connections
                     ssl_context = None

d5m_ai/agent/tools/local/shell.py

@@ -40,20 +40,41 @@ class ShellExecutor:
         'chmod 777', 'chmod -R 777', 'chown -R', 'passwd', 'su -',
         'sudo su', 'sudo rm', 'sudo chmod', 'sudo chown',
         'nc ', 'netcat',
-        'python -c', 'python3 -c', 'eval', 'exec', 'import os'
+        'python -c', 'python3 -c', 'eval', 'exec', 'import os',
+        # Package managers / networked operations (require explicit permission)
+        'pip install', 'pip uninstall', 'pip download',
+        'conda install', 'conda update', 'conda remove',
+        'npm install', 'npm i', 'npm add',
+        'yarn add', 'yarn install',
+        'pnpm add', 'pnpm install',
+        # Git operations that modify state or reach network (require permission)
+        'git checkout', 'git switch', 'git reset', 'git clean',
+        'git pull', 'git push', 'git fetch',
     ]
     
     # Safe commands that are allowed without permission.
     SAFE_COMMANDS = [
         'ls', 'dir', 'pwd', 'whoami', 'id', 'date', 'uptime', 'uname',
+        'hostname', 'sw_vers',
         'df', 'du', 'free', 'ps', 'top', 'htop', 'which', 'where',
         'cat', 'head', 'tail', 'wc', 'grep', 'find', 'locate',
         'echo', 'env', 'printenv', 'history', 'file', 'stat',
-        'mount', 'lsblk', 'lscpu', 'lsmem', 'lsusb', 'lspci',
+        'tree', 'jq',
+        'lsblk', 'lscpu', 'lsmem', 'lsusb', 'lspci',
         'ifconfig', 'ip', 'netstat', 'ss', 'ping', 'traceroute',
-        'git status', 'git log', 'git branch', 'git diff',
-        'npm list', 'pip list', 'pip show', 'conda list',
-        'docker ps', 'docker images', 'kubectl get', 'pip', 'pip install', 'streamlit', 'streamlit run', 'chmod'
+        # Git (read-only)
+        'git status', 'git log', 'git branch', 'git diff', 'git show', 'git rev-parse', 'git --version',
+        # Node/Python package tools (read-only)
+        'npm list', 'npm ls', 'npm --version', 'npm -v',
+        'pip list', 'pip show', 'pip check', 'pip --version', 'pip -v', 'pip -V',
+        'conda list', 'conda info', 'conda --version',
+        # Container / cluster inspection (read-only)
+        'docker ps', 'docker images', 'docker --version', 'docker version',
+        'kubectl get', 'kubectl version',
+        # Jupyter tooling (explicitly allow nbconvert and kernelspec listing)
+        'jupyter --version', 'jupyter nbconvert', 'jupyter kernelspec',
+        # Convenience built-ins (cd is handled specially, but we still allow it)
+        'cd',
     ]
     
     def __init__(self, permission_handler: PermissionHandler = None):
@@ -64,6 +85,9 @@ class ShellExecutor:
             permission_handler: Handler for requesting user permissions for dangerous commands.
         """
         self.permission_handler = permission_handler
+        # Track working directory across commands. Plain `cd ...` in a subprocess
+        # does not persist; we implement `cd` as a built-in in execute_command.
+        self.cwd = os.getcwd()
     
     def analyze_command_safety(self, command: str) -> Dict[str, Any]:
         """
@@ -103,8 +127,8 @@ class ShellExecutor:
             
             base_command = command_parts[0]
             
-            # Allow git, npm, pip, conda, docker, kubectl with subcommands.
-            if base_command in ['git', 'npm', 'pip', 'conda', 'docker', 'kubectl']:
+            # Allow a limited set of subcommands for multi-tool CLIs.
+            if base_command in ['git', 'npm', 'pip', 'conda', 'docker', 'kubectl', 'jupyter']:
                 if len(command_parts) < 2:
                     return False
                 full_command = f"{base_command} {command_parts[1]}"
@@ -127,6 +151,24 @@ class ShellExecutor:
         """
         # Analyze command safety.
         safety_analysis = self.analyze_command_safety(command)
+
+        # Built-in: support `cd` by updating the executor's working directory.
+        try:
+            parts = shlex.split(command)
+        except Exception:
+            parts = []
+        if parts and parts[0].lower() == "cd":
+            if len(parts) == 1:
+                target = os.path.expanduser("~")
+            else:
+                target = os.path.expanduser(parts[1])
+                if not os.path.isabs(target):
+                    target = os.path.join(self.cwd, target)
+            target = os.path.realpath(target)
+            if not os.path.isdir(target):
+                return f"Error: directory does not exist: {target}"
+            self.cwd = target
+            return f"Changed directory to: {self.cwd}"
         
         # Handle dangerous commands.
         if safety_analysis["is_dangerous"]:
@@ -140,12 +182,20 @@ class ShellExecutor:
             
             if not permission_granted:
                 return f"Command execution cancelled by user. Command was: {command}"
-        
-        # Handle non-dangerous commands that aren't in safe list.
+
+        # If not allowlisted, ask for permission (instead of hard-blocking).
         elif not safety_analysis["is_safe_command"]:
-            command_parts = shlex.split(command.lower()) if command else []
-            base_command = command_parts[0] if command_parts else "unknown"
-            return f"Error: Command '{base_command}' is not in the allowed commands list"
+            if not self.permission_handler:
+                command_parts = shlex.split(command.lower()) if command else []
+                base_command = command_parts[0] if command_parts else "unknown"
+                return f"Error: Command '{base_command}' is not in the allowed commands list and no permission handler is available."
+
+            permission_granted = await self.permission_handler.request_permission(
+                command,
+                "not_allowlisted",
+            )
+            if not permission_granted:
+                return f"Command execution cancelled by user. Command was: {command}"
         
         # Execute the command.
         return await self._execute_safe_command(command)
@@ -162,7 +212,7 @@ class ShellExecutor:
                 capture_output=True,
                 text=True,
                 timeout=90,
-                cwd=os.getcwd()
+                cwd=self.cwd
             )
             
             # Combine stdout and stderr.

d5m_ai/chat/chat_proxy_handler.py

@@ -190,7 +190,7 @@ class AIChatProxyHandler(APIHandler):
             if not user_token:
                 self.set_status(401)
                 self.finish(json.dumps({
-                    "error": "You're signed out. Please sign in to continue using D5M AI.",
+                    "error": "Authentication required. You may not be signed in or there may be an issue with your authentication. Please try signing in again.",
                     "status": "auth_required",
                     "debug_info": {
                         "frontend_integration_needed": True,

d5m_ai/completion/__init__.py

@@ -65,6 +65,11 @@ class CompletionHandler(APIHandler):
                 mime = body.get('mime', 'text/x-python')
                 path = body.get('path')
                 cell_id = body.get('cell_id')
+                mode = body.get('mode')
+                region_text = body.get('region_text')
+                cursor_offset = body.get('cursor_offset')
+                region_start_line = body.get('region_start_line')
+                region_start_column = body.get('region_start_column')
             except KeyError as e:
                 raise HTTPError(400, f"Missing required field: {e}")
             
@@ -76,7 +81,12 @@ class CompletionHandler(APIHandler):
                 "language": language,
                 "mime": mime,
                 "path": path,
-                "cell_id": cell_id
+                "cell_id": cell_id,
+                "mode": mode,
+                "region_text": region_text,
+                "cursor_offset": cursor_offset,
+                "region_start_line": region_start_line,
+                "region_start_column": region_start_column
             }
 
             # Forward request to remote server

d5m_ai/edit/shell_executor.py

@@ -7,6 +7,10 @@ import uuid
 
 class ShellExecutor:
     def __init__(self):
+        # Track working directory across commands. Note that plain `cd ...` in a
+        # subprocess does not persist; we implement `cd` as a built-in below.
+        self.cwd = os.getcwd()
+
         self.dangerous_patterns = [
             'rm -rf', 'rm -r', 'rmdir', 'del', 'format', 'fdisk',
             'mkfs', 'dd if=', 'dd of=', '> /dev/', 'shutdown', 'reboot',
@@ -14,19 +18,40 @@ class ShellExecutor:
             'chmod 777', 'chmod -R 777', 'chown -R', 'passwd', 'su -',
             'sudo su', 'sudo rm', 'sudo chmod', 'sudo chown', '&&', '||',
             ';', '|', '>', '>>', '<', 'curl', 'wget', 'nc ', 'netcat',
-            'python -c', 'python3 -c', 'eval', 'exec', 'import os'
+            'python -c', 'python3 -c', 'eval', 'exec', 'import os',
+            # Package managers / networked operations (require explicit permission)
+            'pip install', 'pip uninstall', 'pip download',
+            'conda install', 'conda update', 'conda remove',
+            'npm install', 'npm i', 'npm add',
+            'yarn add', 'yarn install',
+            'pnpm add', 'pnpm install',
+            # Git operations that modify state or reach network (require permission)
+            'git checkout', 'git switch', 'git reset', 'git clean',
+            'git pull', 'git push', 'git fetch',
         ]
         
         self.safe_commands = [
             'ls', 'dir', 'pwd', 'whoami', 'id', 'date', 'uptime', 'uname',
+            'hostname', 'sw_vers',
             'df', 'du', 'free', 'ps', 'top', 'htop', 'which', 'where',
             'cat', 'head', 'tail', 'wc', 'grep', 'find', 'locate',
             'echo', 'env', 'printenv', 'history', 'file', 'stat',
-            'mount', 'lsblk', 'lscpu', 'lsmem', 'lsusb', 'lspci',
+            'tree', 'jq',
+            'lsblk', 'lscpu', 'lsmem', 'lsusb', 'lspci',
             'ifconfig', 'ip', 'netstat', 'ss', 'ping', 'traceroute',
-            'git status', 'git log', 'git branch', 'git diff',
-            'npm list', 'pip list', 'pip show', 'conda list',
-            'docker ps', 'docker images', 'kubectl get', 'pip', 'pip install', 'streamlit', 'streamlit run', 'chmod'
+            # Git (read-only)
+            'git status', 'git log', 'git branch', 'git diff', 'git show', 'git rev-parse', 'git --version',
+            # Node/Python package tools (read-only)
+            'npm list', 'npm ls', 'npm --version', 'npm -v',
+            'pip list', 'pip show', 'pip check', 'pip --version', 'pip -v', 'pip -V',
+            'conda list', 'conda info', 'conda --version',
+            # Container / cluster inspection (read-only)
+            'docker ps', 'docker images', 'docker --version', 'docker version',
+            'kubectl get', 'kubectl version',
+            # Jupyter tooling (explicitly allow nbconvert and kernelspec listing)
+            'jupyter --version', 'jupyter nbconvert', 'jupyter kernelspec',
+            # Convenience built-ins (cd is handled specially, but we still allow it)
+            'cd',
         ]
 
     def _is_dangerous_command(self, command):
@@ -46,12 +71,13 @@ class ShellExecutor:
             
         base_command = command_parts[0]
         
-        # Allow git, npm, pip, conda, docker, kubectl with subcommands
-        if base_command in ['git', 'npm', 'pip', 'conda', 'docker', 'kubectl']:
+        # Allow a limited set of subcommands for multi-tool CLIs.
+        if base_command in ['git', 'npm', 'pip', 'conda', 'docker', 'kubectl', 'jupyter']:
             if len(command_parts) < 2:
-                return False, f"{base_command} requires a subcommand"
+                return False, f"{base_command} requires a subcommand or flag"
             full_command = f"{base_command} {command_parts[1]}"
-            if full_command not in [cmd for cmd in self.safe_commands if cmd.startswith(base_command)]:
+            allowed = {cmd for cmd in self.safe_commands if cmd.startswith(f"{base_command} ")}
+            if full_command not in allowed:
                 return False, f"{full_command} is not in the allowed commands list"
         elif base_command not in [cmd.split()[0] for cmd in self.safe_commands]:
             return False, f"Command '{base_command}' is not in the allowed commands list"
@@ -95,18 +121,40 @@ class ShellExecutor:
         """
         # Safety check - identify potentially dangerous commands
         is_dangerous, dangerous_pattern = self._is_dangerous_command(command)
-        
-        # If dangerous command detected, ask for user confirmation
+
+        # Built-in: support `cd` by updating the executor's working directory.
+        try:
+            parts = shlex.split(command)
+        except Exception:
+            parts = []
+        if parts and parts[0].lower() == "cd":
+            if len(parts) == 1:
+                target = os.path.expanduser("~")
+            else:
+                target = os.path.expanduser(parts[1])
+                if not os.path.isabs(target):
+                    target = os.path.join(self.cwd, target)
+            target = os.path.realpath(target)
+            if not os.path.isdir(target):
+                return f"Error: directory does not exist: {target}"
+            self.cwd = target
+            return f"Changed directory to: {self.cwd}"
+
+        # If dangerous OR not allowlisted, ask for user confirmation.
         if is_dangerous:
             permission_granted = await self.request_permission(handler, command, dangerous_pattern)
             if not permission_granted:
                 return f"Command execution cancelled by user. Command was: {command}"
-        
-        # Additional safety: only allow specific safe commands (for non-dangerous commands)
-        if not is_dangerous:
+        else:
             is_safe, error_msg = self._is_safe_command(command)
             if not is_safe:
-                return f"Error: {error_msg}"
+                permission_granted = await self.request_permission(
+                    handler,
+                    command,
+                    f"not_allowlisted: {error_msg}",
+                )
+                if not permission_granted:
+                    return f"Command execution cancelled by user. Command was: {command}"
         
         try:
             print(f"[SHELL] Executing command: {command}")
@@ -118,7 +166,7 @@ class ShellExecutor:
                 capture_output=True,
                 text=True,
                 timeout=90,  # 30 second timeout
-                cwd=os.getcwd()  # Run in current working directory
+                cwd=self.cwd  # Run in tracked working directory
             )
             
             # Combine stdout and stderr

d5m_ai/empty_display/__init__.py

@@ -0,0 +1,3 @@
+from .empty_display_handler import EmptyDisplayProxyHandler
+
+__all__ = ["EmptyDisplayProxyHandler"]

d5m_ai/empty_display/empty_display_handler.py

@@ -0,0 +1,137 @@
+"""
+Empty display proxy handler.
+
+Forwards empty state display requests to the SaaS backend to avoid CORS issues.
+"""
+
+import asyncio
+import aiohttp
+import certifi
+import json
+import logging
+import os
+import ssl
+from typing import Optional
+from urllib.parse import urlparse
+
+from jupyter_server.base.handlers import APIHandler
+from tornado import web
+
+from ..auth.token_handler import get_current_user_token_string
+
+logging.basicConfig(level=logging.INFO)
+
+DEFAULT_SAAS_URL = "https://www.runcell.dev"
+ALLOWED_HOST_SUFFIXES = (".runcell.dev",)
+ALLOWED_HOSTS = {"runcell.dev", "www.runcell.dev", "localhost", "127.0.0.1"}
+
+
+def _is_allowed_host(hostname: str) -> bool:
+    if not hostname:
+        return False
+    hostname = hostname.lower()
+    if hostname in ALLOWED_HOSTS:
+        return True
+    return any(hostname.endswith(suffix) for suffix in ALLOWED_HOST_SUFFIXES)
+
+
+class EmptyDisplayProxyHandler(APIHandler):
+    """Proxy handler for empty display requests."""
+
+    def _create_ssl_context(self):
+        try:
+            certifi_ca_bundle = certifi.where()
+            return ssl.create_default_context(cafile=certifi_ca_bundle)
+        except Exception as error:
+            logging.warning(f"[EMPTY-DISPLAY-PROXY] Failed to use certifi CA bundle: {error}")
+            return ssl.create_default_context()
+
+    def _resolve_saas_url(self, saas_url: Optional[str]) -> str:
+        candidate = saas_url or os.environ.get("D5M_SAAS_URL") or DEFAULT_SAAS_URL
+        candidate = candidate.strip()
+
+        parsed = urlparse(candidate)
+        if not parsed.scheme or not parsed.netloc:
+            raise ValueError("Invalid SaaS URL")
+
+        if not _is_allowed_host(parsed.hostname or ""):
+            raise ValueError("SaaS URL host not allowed")
+
+        return f"{parsed.scheme}://{parsed.netloc}".rstrip("/")
+
+    def _extract_token(self) -> Optional[str]:
+        local_token = get_current_user_token_string()
+        if local_token:
+            return local_token
+
+        auth_header = self.request.headers.get("Authorization", "")
+        if auth_header.startswith("Bearer "):
+            return auth_header[7:]
+
+        return None
+
+    @web.authenticated
+    async def post(self):
+        try:
+            try:
+                body = json.loads(self.request.body or b"{}")
+            except json.JSONDecodeError:
+                self.set_status(400)
+                self.finish(json.dumps({"error": "Invalid JSON in request body"}))
+                return
+
+            ping_status = body.get("ping_status") or {}
+            payload = {
+                "runcell_version": body.get("runcell_version", ""),
+                "ping_status": {
+                    "local": bool(ping_status.get("local")),
+                    "remote": bool(ping_status.get("remote"))
+                }
+            }
+
+            if "logged_in" in body:
+                payload["logged_in"] = bool(body.get("logged_in"))
+            if "user_id" in body:
+                payload["user_id"] = body.get("user_id")
+
+            try:
+                saas_url = self._resolve_saas_url(body.get("saas_url"))
+            except ValueError as error:
+                self.set_status(400)
+                self.finish(json.dumps({"error": str(error)}))
+                return
+
+            user_token = self._extract_token()
+            headers = {"Content-Type": "application/json"}
+            if user_token:
+                headers["Authorization"] = f"Bearer {user_token}"
+
+            ssl_context = self._create_ssl_context()
+            timeout = aiohttp.ClientTimeout(total=10)
+
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                url = f"{saas_url}/api/plugin-auth/empty_display"
+                logging.info(f"[EMPTY-DISPLAY-PROXY] Forwarding request to: {url}")
+                async with session.post(url, json=payload, headers=headers, ssl=ssl_context) as response:
+                    response_text = await response.text()
+                    if response.status == 200:
+                        try:
+                            response_data = json.loads(response_text)
+                            self.finish(json.dumps(response_data))
+                        except json.JSONDecodeError:
+                            logging.error("[EMPTY-DISPLAY-PROXY] Invalid JSON response")
+                            self.set_status(502)
+                            self.finish(json.dumps({"error": "Invalid response from server"}))
+                    else:
+                        logging.error(f"[EMPTY-DISPLAY-PROXY] Remote error {response.status}: {response_text}")
+                        self.set_status(response.status)
+                        self.finish(response_text)
+
+        except asyncio.TimeoutError:
+            logging.error("[EMPTY-DISPLAY-PROXY] Request timeout")
+            self.set_status(408)
+            self.finish(json.dumps({"error": "Request timeout"}))
+        except Exception as error:
+            logging.error(f"[EMPTY-DISPLAY-PROXY] Unexpected error: {error}")
+            self.set_status(500)
+            self.finish(json.dumps({"error": f"Internal server error: {error}"}))

d5m_ai/extension.py

@@ -13,8 +13,10 @@ from .sandbox.shell_exec import ShellExecHandler
 from .chat.code_apply import CodeApplyHandler
 from .mention.mention_file_handler import MentionFileHandler
 from .auth.token_handler import TokenHandler
-from .ping.ping_handler import PingProxyHandler
+from .ping.ping_handler import PingProxyHandler, PingLocalHandler
+from .empty_display import EmptyDisplayProxyHandler
 from .title import TitleGenerationHandler
+from .quick_fix import QuickFixApplyHandler
 
 from .completion import CompletionHandler
 from .edit import AIEditChatHandler
@@ -25,6 +27,9 @@ from .agent import AIJLAgentProxyHandler
 from .agent.config import IMAGE_DIR
 from .image import get_image_handlers
 from .upgrade import UpgradeEnvironmentHandler, UpgradeHandler
+from .gitignore_handler import GitIgnoreHandler
+from .git_status_handler import GitStatusHandler
+from .search_replace_handler import SearchReplaceHandler
 
 # Static file handler for serving image files
 class ImageFileHandler(web.StaticFileHandler):
@@ -62,9 +67,15 @@ class D5MAIExtensionApp(ExtensionApp):
             (r"/api/d5m_ai/mention/files", MentionFileHandler),
             (r"/api/d5m_ai/auth/token", TokenHandler),
             (r"/api/d5m_ai/ping", PingProxyHandler),
+            (r"/api/d5m_ai/ping_local", PingLocalHandler),
+            (r"/api/d5m_ai/empty_display", EmptyDisplayProxyHandler),
             (r"/api/d5m_ai/generate_title", TitleGenerationHandler),
+            (r"/api/d5m_ai/quick_fix_apply", QuickFixApplyHandler),
             (r"/api/d5m_ai/upgrade/info", UpgradeEnvironmentHandler),
             (r"/api/d5m_ai/upgrade", UpgradeHandler),
+            (r"/api/d5m_ai/gitignore", GitIgnoreHandler),
+            (r"/api/d5m_ai/git-status", GitStatusHandler),
+            (r"/api/d5m_ai/search_replace", SearchReplaceHandler),
             # Static file handler for the temporary image files
             (r"/d5m-ai/images/(.*)", ImageFileHandler, {"path": IMAGE_DIR}),
         ]