griptape-nodes 0.52.1__py3-none-any.whl → 0.54.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

@@ -7,7 +7,6 @@ import os
 import sys
 import threading
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Any
 from urllib.parse import urljoin
 
@@ -16,10 +15,8 @@ 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
 from griptape_nodes.retained_mode.events import app_events, execution_events
 
 # This import is necessary to register all events, even if not technically used
@@ -63,6 +60,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
@@ -75,19 +77,10 @@ websocket_event_loop: asyncio.AbstractEventLoop | None = None
 websocket_event_loop_ready = threading.Event()
 
 
-# Whether to enable the static server
-STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "true"
-
 # Semaphore to limit concurrent requests
 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 +98,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()
 
@@ -134,14 +129,6 @@ async def astart_app() -> None:
     main_loop = asyncio.get_running_loop()
 
     try:
-        # Start MCP server in daemon thread
-        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()
-
-        # Start static server in daemon thread if enabled
-        if STATIC_SERVER_ENABLED:
-            static_dir = _build_static_dir()
-            threading.Thread(target=start_static_server, args=(static_dir,), daemon=True, name="static-server").start()
-
         # Start WebSocket tasks in daemon thread
         threading.Thread(
             target=_start_websocket_connection, args=(api_key, main_loop), daemon=True, name="websocket-tasks"
@@ -186,12 +173,11 @@ async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoo
     initialized = False
 
     async for ws_connection in connection_stream:
+        logger.debug("WebSocket connection established")
         try:
             # Emit initialization event only for the first connection
             if not initialized:
-                griptape_nodes.EventManager().put_event_threadsafe(
-                    main_loop, AppEvent(payload=app_events.AppInitializationComplete())
-                )
+                griptape_nodes.EventManager().put_event(AppEvent(payload=app_events.AppInitializationComplete()))
                 initialized = True
 
             # Emit connection established event for every connection
@@ -202,9 +188,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:
@@ -227,36 +217,16 @@ def _ensure_api_key() -> str:
     return api_key
 
 
-def _build_static_dir() -> Path:
-    """Build the static directory path based on the workspace configuration."""
-    config_manager = griptape_nodes.ConfigManager()
-    return Path(config_manager.workspace_path) / config_manager.merged_config["static_files_directory"]
-
-
 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 +283,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 +323,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 +335,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:
@@ -382,7 +344,7 @@ async def _send_unsubscribe_command(ws_connection: Any, topic: str) -> None:
 
 async def _process_event_queue() -> None:
     """Process events concurrently - runs on main thread."""
-    logger.info("Starting event queue processor on main thread")
+    logger.debug("Starting event queue processor on main thread")
     background_tasks = set()
 
     def _handle_task_result(task: asyncio.Task) -> None:
@@ -415,7 +377,7 @@ async def _process_event_queue() -> None:
             task.add_done_callback(_handle_task_result)
             event_queue.task_done()
     except asyncio.CancelledError:
-        logger.info("Event queue processor shutdown complete")
+        logger.debug("Event queue processor shutdown complete")
         raise
 
 

griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any, Self
 
 from griptape_nodes.bootstrap.workflow_executors.workflow_executor import WorkflowExecutor
 from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.exe_types.node_types import EndNode, StartNode
+from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import (
     EventRequest,
     ExecutionGriptapeNodeEvent,
@@ -15,6 +18,9 @@ from griptape_nodes.retained_mode.events.workflow_events import (
 )
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
+if TYPE_CHECKING:
+    from types import TracebackType
+
 logger = logging.getLogger(__name__)
 
 
@@ -23,6 +29,29 @@ class LocalExecutorError(Exception):
 
 
 class LocalWorkflowExecutor(WorkflowExecutor):
+    def __init__(
+        self,
+        storage_backend: StorageBackend = StorageBackend.LOCAL,
+    ):
+        super().__init__()
+        self._set_storage_backend(storage_backend=storage_backend)
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry: initialize queue and broadcast app initialization."""
+        GriptapeNodes.EventManager().initialize_queue()
+        await GriptapeNodes.EventManager().broadcast_app_event(AppInitializationComplete())
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit."""
+        # TODO: Broadcast shutdown https://github.com/griptape-ai/griptape-nodes/issues/2149
+        return
+
     def _load_flow_for_workflow(self) -> str:
         try:
             context_manager = GriptapeNodes.ContextManager()
@@ -124,7 +153,7 @@ class LocalWorkflowExecutor(WorkflowExecutor):
         self,
         workflow_name: str,
         flow_input: Any,
-        storage_backend: StorageBackend = StorageBackend.LOCAL,
+        storage_backend: StorageBackend | None = None,
         **kwargs: Any,
     ) -> None:
         """Executes a local workflow.
@@ -140,12 +169,13 @@ class LocalWorkflowExecutor(WorkflowExecutor):
         Returns:
             None
         """
+        if storage_backend is not None:
+            msg = "The storage_backend parameter is deprecated. Pass `storage_backend` to the constructor instead."
+            raise ValueError(msg)
+
         logger.info("Executing workflow: %s", workflow_name)
         GriptapeNodes.EventManager().initialize_queue()
 
-        # Set the storage backend
-        self._set_storage_backend(storage_backend=storage_backend)
-
         # Load workflow from file if workflow_path is provided
         workflow_path = kwargs.get("workflow_path")
         if workflow_path:

griptape_nodes/bootstrap/workflow_executors/workflow_executor.py

@@ -1,7 +1,8 @@
 import asyncio
 import logging
 from abc import abstractmethod
-from typing import Any
+from types import TracebackType
+from typing import Any, Self
 
 from griptape_nodes.drivers.storage import StorageBackend
 
@@ -12,6 +13,19 @@ class WorkflowExecutor:
     def __init__(self) -> None:
         self.output: dict | None = None
 
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit."""
+        return
+
     def run(
         self,
         workflow_name: str,

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,74 @@
+"""Config command for Griptape Nodes CLI."""
+
+import json
+import sys
+
+import typer
+
+from griptape_nodes.cli.shared import console
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+config_manager = GriptapeNodes.ConfigManager()
+
+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()