griptape-nodes 0.52.1__py3-none-any.whl → 0.53.0__py3-none-any.whl

griptape_nodes/__main__.py

@@ -0,0 +1,6 @@
+"""Main entry point for the Griptape Nodes CLI when run as a module."""
+
+from griptape_nodes import main
+
+if __name__ == "__main__":
+    main()

griptape_nodes/app/app.py

@@ -16,7 +16,7 @@ from rich.console import Console
 from rich.logging import RichHandler
 from rich.panel import Panel
 from websockets.asyncio.client import connect
-from websockets.exceptions import ConnectionClosed, WebSocketException
+from websockets.exceptions import ConnectionClosed, ConnectionClosedError, WebSocketException
 
 from griptape_nodes.app.api import start_static_server
 from griptape_nodes.mcp_server.server import start_mcp_server
@@ -63,6 +63,11 @@ class UnsubscribeCommand:
     topic: str
 
 
+# Important to bootstrap singleton here so that we don't
+# get any weird circular import issues from the EventLogHandler
+# initializing it from a log during it's own initialization.
+griptape_nodes: GriptapeNodes = GriptapeNodes()
+
 # WebSocket outgoing queue for messages and commands.
 # Appears to be fine to create outside event loop
 # https://discuss.python.org/t/can-asyncio-queue-be-safely-created-outside-of-the-event-loop-thread/49215/8
@@ -82,12 +87,6 @@ STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "t
 REQUEST_SEMAPHORE = asyncio.Semaphore(100)
 
 
-# Important to bootstrap singleton here so that we don't
-# get any weird circular import issues from the EventLogHandler
-# initializing it from a log during it's own initialization.
-griptape_nodes: GriptapeNodes = GriptapeNodes()
-
-
 class EventLogHandler(logging.Handler):
     """Custom logging handler that emits log messages as AppEvents.
 
@@ -105,10 +104,12 @@ class EventLogHandler(logging.Handler):
 logger = logging.getLogger("griptape_nodes_app")
 
 griptape_nodes_logger = logging.getLogger("griptape_nodes")
-# When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
-griptape_nodes_logger.addHandler(EventLogHandler())
-griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
-griptape_nodes_logger.setLevel(logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[EventLogHandler(), RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True)],
+)
 
 console = Console()
 
@@ -186,6 +187,7 @@ async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoo
     initialized = False
 
     async for ws_connection in connection_stream:
+        logger.info("WebSocket connection established")
         try:
             # Emit initialization event only for the first connection
             if not initialized:
@@ -202,9 +204,13 @@ async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoo
             async with asyncio.TaskGroup() as tg:
                 tg.create_task(_process_incoming_messages(ws_connection, main_loop))
                 tg.create_task(_send_outgoing_messages(ws_connection))
-        except* Exception as e:
-            logger.error("WebSocket tasks failed: %s", e.exceptions)
+        except (ExceptionGroup, ConnectionClosed, ConnectionClosedError):
+            logger.info("WebSocket connection closed, reconnecting...")
+            continue
+        except Exception:
+            logger.exception("WebSocket tasks failed")
             await asyncio.sleep(2.0)  # Wait before retry
+            continue
 
 
 def _ensure_api_key() -> str:
@@ -235,28 +241,14 @@ def _build_static_dir() -> Path:
 
 async def _process_incoming_messages(ws_connection: Any, main_loop: asyncio.AbstractEventLoop) -> None:
     """Process incoming WebSocket requests from Nodes API."""
-    logger.info("Processing incoming WebSocket requests from WebSocket connection")
+    logger.debug("Processing incoming WebSocket requests from WebSocket connection")
 
-    try:
-        async for message in ws_connection:
-            try:
-                data = json.loads(message)
-                await _process_api_event(data, main_loop)
-            except Exception:
-                logger.exception("Error processing event, skipping.")
-
-    except ConnectionClosed:
-        logger.info("WebSocket connection closed, will retry")
-    except asyncio.CancelledError:
-        # Clean shutdown when task is cancelled
-        logger.info("WebSocket listener shutdown complete")
-        raise
-    except Exception as e:
-        logger.error("Error in WebSocket connection. Retrying in 2 seconds... %s", e)
-        await asyncio.sleep(2.0)
-        raise
-    finally:
-        logger.info("WebSocket listener shutdown complete")
+    async for message in ws_connection:
+        try:
+            data = json.loads(message)
+            await _process_api_event(data, main_loop)
+        except Exception:
+            logger.exception("Error processing event, skipping.")
 
 
 def _create_websocket_connection(api_key: str) -> Any:
@@ -313,33 +305,25 @@ async def _process_api_event(event: dict, main_loop: asyncio.AbstractEventLoop)
 
 async def _send_outgoing_messages(ws_connection: Any) -> None:
     """Send outgoing WebSocket requests from queue on background thread."""
-    logger.info("Starting outgoing WebSocket request sender")
+    logger.debug("Starting outgoing WebSocket request sender")
 
-    try:
-        while True:
-            # Get message from outgoing queue
-            message = await ws_outgoing_queue.get()
-
-            try:
-                if isinstance(message, WebSocketMessage):
-                    await _send_websocket_message(ws_connection, message.event_type, message.payload, message.topic)
-                elif isinstance(message, SubscribeCommand):
-                    await _send_subscribe_command(ws_connection, message.topic)
-                elif isinstance(message, UnsubscribeCommand):
-                    await _send_unsubscribe_command(ws_connection, message.topic)
-                else:
-                    logger.warning("Unknown outgoing message type: %s", type(message))
-            except Exception as e:
-                logger.error("Error sending outgoing WebSocket request: %s", e)
-            finally:
-                ws_outgoing_queue.task_done()
+    while True:
+        # Get message from outgoing queue
+        message = await ws_outgoing_queue.get()
 
-    except asyncio.CancelledError:
-        logger.info("Outbound request sender shutdown complete")
-        raise
-    except Exception as e:
-        logger.error("Fatal error in outgoing request sender: %s", e)
-        raise
+        try:
+            if isinstance(message, WebSocketMessage):
+                await _send_websocket_message(ws_connection, message.event_type, message.payload, message.topic)
+            elif isinstance(message, SubscribeCommand):
+                await _send_subscribe_command(ws_connection, message.topic)
+            elif isinstance(message, UnsubscribeCommand):
+                await _send_unsubscribe_command(ws_connection, message.topic)
+            else:
+                logger.warning("Unknown outgoing message type: %s", type(message))
+        except Exception as e:
+            logger.error("Error sending outgoing WebSocket request: %s", e)
+        finally:
+            ws_outgoing_queue.task_done()
 
 
 async def _send_websocket_message(ws_connection: Any, event_type: str, payload: str, topic: str | None) -> None:
@@ -361,7 +345,7 @@ async def _send_subscribe_command(ws_connection: Any, topic: str) -> None:
     try:
         body = {"type": "subscribe", "topic": topic, "payload": {}}
         await ws_connection.send(json.dumps(body))
-        logger.info("Subscribed to topic: %s", topic)
+        logger.debug("Subscribed to topic: %s", topic)
     except WebSocketException as e:
         logger.error("Error subscribing to topic %s: %s", topic, e)
     except Exception as e:
@@ -373,7 +357,7 @@ async def _send_unsubscribe_command(ws_connection: Any, topic: str) -> None:
     try:
         body = {"type": "unsubscribe", "topic": topic, "payload": {}}
         await ws_connection.send(json.dumps(body))
-        logger.info("Unsubscribed from topic: %s", topic)
+        logger.debug("Unsubscribed from topic: %s", topic)
     except WebSocketException as e:
         logger.error("Error unsubscribing from topic %s: %s", topic, e)
     except Exception as e:

griptape_nodes/cli/__init__.py

@@ -0,0 +1 @@
+"""Griptape Nodes CLI module."""

griptape_nodes/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Griptape Nodes CLI commands."""

griptape_nodes/cli/commands/config.py

@@ -0,0 +1,71 @@
+"""Config command for Griptape Nodes CLI."""
+
+import json
+import sys
+
+import typer
+
+from griptape_nodes.cli.shared import config_manager, console
+
+app = typer.Typer(help="Manage configuration.")
+
+
+@app.command()
+def show(
+    config_path: str = typer.Argument(
+        None,
+        help="Optional config path to show specific value (e.g., 'workspace_directory').",
+    ),
+) -> None:
+    """Show configuration values."""
+    _print_user_config(config_path)
+
+
+@app.command("list")
+def list_configs() -> None:
+    """List configuration values."""
+    _list_user_configs()
+
+
+@app.command()
+def reset() -> None:
+    """Reset configuration to defaults."""
+    _reset_user_config()
+
+
+def _print_user_config(config_path: str | None = None) -> None:
+    """Prints the user configuration from the config file.
+
+    Args:
+        config_path: Optional path to specific config value. If None, prints entire config.
+    """
+    if config_path is None:
+        config = config_manager.merged_config
+        sys.stdout.write(json.dumps(config, indent=2))
+    else:
+        try:
+            value = config_manager.get_config_value(config_path)
+            if isinstance(value, (dict, list)):
+                sys.stdout.write(json.dumps(value, indent=2))
+            else:
+                sys.stdout.write(str(value))
+        except (KeyError, AttributeError, ValueError):
+            console.print(f"[bold red]Config path '{config_path}' not found[/bold red]")
+            sys.exit(1)
+
+
+def _list_user_configs() -> None:
+    """Lists user configuration files in ascending precedence."""
+    num_config_files = len(config_manager.config_files)
+    console.print(
+        f"[bold]User Configuration Files (lowest precedence (1.) ⟶ highest precedence ({num_config_files}.)):[/bold]"
+    )
+    for idx, config in enumerate(config_manager.config_files):
+        console.print(f"[green]{idx + 1}. {config}[/green]")
+
+
+def _reset_user_config() -> None:
+    """Resets the user configuration to the default values."""
+    console.print("[bold]Resetting user configuration to default values...[/bold]")
+    config_manager.reset_user_config()
+    console.print("[bold green]User configuration reset complete![/bold green]")

griptape_nodes/cli/commands/engine.py

@@ -0,0 +1,80 @@
+"""Engine command for Griptape Nodes CLI."""
+
+import typer
+from rich.prompt import Confirm
+
+from griptape_nodes.app import start_app
+from griptape_nodes.cli.commands.init import _run_init
+from griptape_nodes.cli.commands.self import _get_latest_version, _update_self
+from griptape_nodes.cli.shared import (
+    CONFIG_DIR,
+    ENV_API_KEY,
+    ENV_GTN_BUCKET_NAME,
+    ENV_LIBRARIES_SYNC,
+    ENV_REGISTER_ADVANCED_LIBRARY,
+    ENV_STORAGE_BACKEND,
+    ENV_WORKSPACE_DIRECTORY,
+    PACKAGE_NAME,
+    InitConfig,
+    console,
+)
+from griptape_nodes.utils.version_utils import get_current_version, get_install_source
+
+
+def engine_command(
+    no_update: bool = typer.Option(False, "--no-update", help="Skip the auto-update check."),  # noqa: FBT001
+) -> None:
+    """Run the Griptape Nodes engine."""
+    _start_engine(no_update=no_update)
+
+
+def _start_engine(*, no_update: bool = False) -> None:
+    """Starts the Griptape Nodes engine.
+
+    Args:
+        no_update (bool): If True, skips the auto-update check.
+    """
+    if not CONFIG_DIR.exists():
+        # Default init flow if there is no config directory
+        console.print("[bold green]Config directory not found. Initializing...[/bold green]")
+        _run_init(
+            InitConfig(
+                workspace_directory=ENV_WORKSPACE_DIRECTORY,
+                api_key=ENV_API_KEY,
+                storage_backend=ENV_STORAGE_BACKEND,
+                register_advanced_library=ENV_REGISTER_ADVANCED_LIBRARY,
+                interactive=True,
+                config_values=None,
+                secret_values=None,
+                libraries_sync=ENV_LIBRARIES_SYNC,
+                bucket_name=ENV_GTN_BUCKET_NAME,
+            )
+        )
+
+    # Confusing double negation -- If `no_update` is set, we want to skip the update
+    if not no_update:
+        _auto_update_self()
+
+    console.print("[bold green]Starting Griptape Nodes engine...[/bold green]")
+    start_app()
+
+
+def _auto_update_self() -> None:
+    """Automatically updates the script to the latest version if the user confirms."""
+    console.print("[bold green]Checking for updates...[/bold green]")
+    source, commit_id = get_install_source()
+    current_version = get_current_version()
+    latest_version = _get_latest_version(PACKAGE_NAME, source)
+
+    if source == "git" and commit_id is not None:
+        can_update = commit_id != latest_version
+        update_message = f"Your current engine version, {current_version} ({source} - {commit_id}), doesn't match the latest release, {latest_version}. Update now?"
+    else:
+        can_update = current_version < latest_version
+        update_message = f"Your current engine version, {current_version}, is behind the latest release, {latest_version}. Update now?"
+
+    if can_update:
+        update = Confirm.ask(update_message, default=True)
+
+        if update:
+            _update_self()