2026-04-17 18:42:08 -03:00
import grpc
from concurrent import futures
from google.protobuf.empty_pb2 import Empty
import os
import ctypes
import threading
2026-05-28 09:27:54 -03:00
import contextvars
import datetime
2026-04-17 18:42:08 -03:00
# Suppress harmless but noisy gRPC fork() warnings from pexpect child processes
os . environ [ "GRPC_VERBOSITY" ] = "NONE"
os . environ [ "GRPC_ENABLE_FORK_SUPPORT" ] = "0"
from . import connpy_pb2 , connpy_pb2_grpc , remote_plugin_pb2 , remote_plugin_pb2_grpc
import json
from .utils import to_value , from_value , to_struct , from_struct
from ..services.exceptions import ConnpyError
2026-04-24 19:23:00 -03:00
from .. import printer
2026-04-17 18:42:08 -03:00
2026-05-28 09:27:54 -03:00
_current_user = contextvars . ContextVar ( "current_user" , default = None )
2026-04-17 18:42:08 -03:00
def handle_errors ( func ):
2026-04-24 19:23:00 -03:00
import inspect
if inspect . isgeneratorfunction ( func ):
def wrapper ( * args , ** kwargs ):
try :
for item in func ( * args , ** kwargs ):
yield item
2026-05-28 09:27:54 -03:00
except grpc . RpcError :
raise
2026-04-24 19:23:00 -03:00
except ConnpyError as e :
context = kwargs . get ( "context" ) or args [ - 1 ]
context . abort ( grpc . StatusCode . INTERNAL , str ( e ))
except Exception as e :
2026-05-28 09:27:54 -03:00
if type ( e ) is Exception and not e . args :
raise e
if e . __class__ . __name__ in ( "_AbortError" , "RpcError" ):
raise e
2026-04-24 19:23:00 -03:00
context = kwargs . get ( "context" ) or args [ - 1 ]
context . abort ( grpc . StatusCode . UNKNOWN , str ( e ))
finally :
printer . clear_thread_state ()
return wrapper
else :
def wrapper ( * args , ** kwargs ):
try :
return func ( * args , ** kwargs )
2026-05-28 09:27:54 -03:00
except grpc . RpcError :
raise
2026-04-24 19:23:00 -03:00
except ConnpyError as e :
context = kwargs . get ( "context" ) or args [ - 1 ]
context . abort ( grpc . StatusCode . INTERNAL , str ( e ))
except Exception as e :
2026-05-28 09:27:54 -03:00
if type ( e ) is Exception and not e . args :
raise e
if e . __class__ . __name__ in ( "_AbortError" , "RpcError" ):
raise e
2026-04-24 19:23:00 -03:00
context = kwargs . get ( "context" ) or args [ - 1 ]
context . abort ( grpc . StatusCode . UNKNOWN , str ( e ))
finally :
printer . clear_thread_state ()
return wrapper
2026-04-17 18:42:08 -03:00
class NodeServicer ( connpy_pb2_grpc . NodeServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None , debug = False ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
2026-05-08 18:45:42 -03:00
self . server_debug = debug
if debug :
from rich.console import Console
from ..printer import connpy_theme , get_original_stdout
self . server_console = Console ( theme = connpy_theme , file = get_original_stdout ())
2026-04-17 18:42:08 -03:00
2026-05-28 09:27:54 -03:00
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . nodes
2026-04-17 18:42:08 -03:00
@handle_errors
def interact_node ( self , request_iterator , context ):
import sys
import os
2026-04-27 15:12:07 -03:00
import asyncio
2026-04-17 18:42:08 -03:00
from connpy.core import node
2026-04-27 15:12:07 -03:00
from connpy.tunnels import RemoteStream
import queue
import threading
2026-04-17 18:42:08 -03:00
2026-05-28 09:27:54 -03:00
# Resolve provider once at the start of the RPC stream
provider = self . _get_provider ()
nodes_service = provider . nodes
profile_service = provider . profiles
ai_service = provider . ai
user_config = provider . config
2026-04-17 18:42:08 -03:00
# Fetch first setup packet
try :
first_req = next ( request_iterator )
except StopIteration :
context . abort ( grpc . StatusCode . INVALID_ARGUMENT , "No setup request received" )
unique_id = first_req . id
sftp = first_req . sftp
debug = first_req . debug
2026-05-01 18:55:25 -03:00
2026-05-08 18:45:42 -03:00
if self . server_debug :
self . server_console . print ( f "[debug][DEBUG][/debug] gRPC interact_node request for: [bold cyan] { unique_id } [/bold cyan]" )
2026-04-17 18:42:08 -03:00
2026-04-24 19:23:00 -03:00
if first_req . connection_params_json :
import json
params = json . loads ( first_req . connection_params_json )
base_node_id = params . get ( "base_node" )
# Valid attributes that a node object accepts
valid_attrs = [ 'host' , 'options' , 'logs' , 'password' , 'port' , 'protocol' , 'user' , 'jumphost' ]
2026-04-27 15:12:07 -03:00
2026-04-24 19:23:00 -03:00
fallback_id = f " { unique_id } @remote"
if unique_id == "dynamic" and params . get ( "host" ):
fallback_id = f "dynamic- { params . get ( 'host' ) } @remote"
2026-04-27 15:12:07 -03:00
2026-04-24 19:23:00 -03:00
if base_node_id :
# Look up the base node in config and use its full data
2026-05-28 09:27:54 -03:00
nodes = user_config . _getallnodes ( base_node_id )
2026-04-24 19:23:00 -03:00
if nodes :
2026-05-28 09:27:54 -03:00
device = user_config . getitem ( nodes [ 0 ])
2026-04-24 19:23:00 -03:00
# Override device properties with any passed in params
for attr in valid_attrs :
if attr in params :
device [ attr ] = params [ attr ]
2026-04-27 15:12:07 -03:00
2026-04-24 19:23:00 -03:00
if "tags" in params :
device_tags = device . get ( "tags" , {})
if not isinstance ( device_tags , dict ):
device_tags = {}
device_tags . update ( params [ "tags" ])
device [ "tags" ] = device_tags
2026-04-27 15:12:07 -03:00
2026-04-24 19:23:00 -03:00
node_name = params . get ( "name" , base_node_id )
2026-05-28 09:27:54 -03:00
n = node ( node_name , ** device , config = user_config )
2026-04-24 19:23:00 -03:00
else :
# base_node not found, fall back to dynamic
node_name = params . get ( "name" , fallback_id )
2026-05-28 09:27:54 -03:00
n = node ( node_name , host = params . get ( "host" , "" ), config = user_config )
2026-04-24 19:23:00 -03:00
for attr in valid_attrs :
if attr in params :
setattr ( n , attr , params [ attr ])
if "tags" in params :
n . tags = params [ "tags" ]
else :
node_name = params . get ( "name" , fallback_id )
2026-05-28 09:27:54 -03:00
n = node ( node_name , host = params . get ( "host" , "" ), config = user_config )
2026-04-24 19:23:00 -03:00
for attr in valid_attrs :
if attr in params :
setattr ( n , attr , params [ attr ])
if "tags" in params :
n . tags = params [ "tags" ]
2026-10-19 18:33:02 -03:00
n . _orig_protocol = n . protocol
if sftp :
n . protocol = "sftp"
2026-04-24 19:23:00 -03:00
else :
2026-05-28 15:23:39 -03:00
try :
node_data = user_config . getitem ( unique_id , extract = False )
except ( KeyError , TypeError ):
node_data = None
2026-04-24 19:23:00 -03:00
if not node_data :
context . abort ( grpc . StatusCode . NOT_FOUND , f "Node { unique_id } not found" )
resolved_data = profile_service . resolve_node_data ( node_data )
2026-05-28 09:27:54 -03:00
n = node ( unique_id , ** resolved_data , config = user_config )
2026-04-24 19:23:00 -03:00
if sftp :
n . protocol = "sftp"
2026-04-17 18:42:08 -03:00
2026-05-05 18:24:31 -03:00
# Build a logger that captures debug messages as ANSI-colored bytes for the client
debug_chunks = []
if debug :
from io import StringIO
from rich.console import Console as RichConsole
from ..printer import connpy_theme
from .. import printer as _printer
def remote_logger ( msg_type , message ):
buf = StringIO ()
c = RichConsole ( file = buf , force_terminal = True , width = 120 , theme = connpy_theme )
if msg_type == "debug" :
c . print ( _printer . _format_multiline ( "i" , f "[DEBUG] { message } " , style = "info" ))
elif msg_type == "success" :
c . print ( _printer . _format_multiline ( "✓" , message , style = "success" ))
elif msg_type == "error" :
c . print ( _printer . _format_multiline ( "✗" , message , style = "error" ))
else :
c . print ( str ( message ))
rendered = buf . getvalue ()
if rendered :
# Raw TTY needs \r\n instead of \n
rendered = rendered . replace ( ' \n ' , ' \r\n ' )
debug_chunks . append ( rendered . encode ())
else :
remote_logger = None
connect = n . _connect ( debug = debug , logger = remote_logger )
# Send debug output to client before checking result (always show the command)
for chunk in debug_chunks :
yield connpy_pb2 . InteractResponse ( stdout_data = chunk )
2026-04-17 18:42:08 -03:00
if connect != True :
2026-04-24 19:23:00 -03:00
yield connpy_pb2 . InteractResponse ( success = False , error_message = str ( connect ))
return
2026-04-27 15:12:07 -03:00
2026-04-24 19:23:00 -03:00
# Signal successful connection to the client
yield connpy_pb2 . InteractResponse ( success = True )
2026-04-17 18:42:08 -03:00
# Set initial window size if provided
if first_req . cols > 0 and first_req . rows > 0 :
try :
n . child . setwinsize ( first_req . rows , first_req . cols )
except Exception :
pass
2026-04-27 15:12:07 -03:00
response_queue = queue . Queue ()
remote_stream = RemoteStream ( request_iterator , response_queue )
2026-04-17 18:42:08 -03:00
2026-04-27 15:12:07 -03:00
def run_async_loop ():
try :
n . _setup_interact_environment ( debug = debug , logger = None , async_mode = True )
def resize_callback ( rows , cols ):
try :
n . child . setwinsize ( rows , cols )
except Exception :
pass
2026-05-08 18:45:42 -03:00
async def remote_copilot_handler ( buffer , node_info , stream , child_fd , cmd_byte_positions = None ):
import json
import asyncio
import os
2026-05-15 16:25:18 -03:00
2026-05-28 09:27:54 -03:00
service = ai_service
2026-05-11 12:30:43 -03:00
if node_info is None :
node_info = {}
2026-05-15 16:25:18 -03:00
# Calculate real command blocks from history using the central service
raw_bytes = n . mylog . getvalue () if hasattr ( n , 'mylog' ) else buffer
if not isinstance ( raw_bytes , bytes ):
raw_bytes = str ( raw_bytes ) . encode ()
from connpy.utils import log_cleaner
2026-08-11 11:40:12 -03:00
cleaned_buffer = log_cleaner ( raw_bytes . decode ( errors = 'replace' ))
last_line = cleaned_buffer . split ( ' \n ' )[ - 1 ] . strip () if cleaned_buffer . strip () else "(prompt)"
2026-05-15 16:25:18 -03:00
blocks = service . build_context_blocks ( raw_bytes , n . cmd_byte_positions , node_info , last_line = last_line )
node_info [ "context_blocks" ] = blocks
2026-05-11 12:30:43 -03:00
2026-08-11 11:40:12 -03:00
total_cmds = len ( blocks )
total_lines = len ( cleaned_buffer . split ( ' \n ' ))
if not hasattr ( remote_stream , 'copilot_state' ) or remote_stream . copilot_state is None :
remote_stream . copilot_state = {}
session_state = remote_stream . copilot_state
if isinstance ( node_info , dict ):
for k , v in node_info . items ():
if k in ( 'context_mode' , 'context_cmd' , 'context_lines' , 'persona' , 'trust' , 'os' , 'prompt' ):
session_state [ k ] = v
saved_mode = session_state . get ( 'context_mode' , 0 )
saved_cmd = session_state . get ( 'context_cmd' , 1 )
saved_lines = session_state . get ( 'context_lines' , 50 )
last_total_cmds = session_state . get ( 'last_total_cmds' , None )
last_total_lines = session_state . get ( 'last_total_lines' , None )
is_range = saved_mode in ( 0 , 'RANGE' , 'range' )
is_lines = saved_mode in ( 2 , 'LINES' , 'lines' )
is_single = saved_mode in ( 1 , 'SINGLE' , 'single' )
if is_range or is_single :
2026-08-17 10:20:43 -03:00
is_mission = session_state . get ( 'mission' , {}) . get ( 'active' , False ) or ( isinstance ( node_info , dict ) and node_info . get ( 'mission' , {}) . get ( 'active' , False ))
if last_total_cmds is not None and total_cmds > last_total_cmds and ( saved_cmd > 1 or is_mission ):
2026-08-11 11:40:12 -03:00
new_cmds = total_cmds - last_total_cmds
initial_cmd = saved_cmd + new_cmds
else :
initial_cmd = saved_cmd
initial_lines = saved_lines
elif is_lines :
if last_total_lines is not None and total_lines > last_total_lines and saved_lines > 50 :
new_lines = total_lines - last_total_lines
initial_lines = saved_lines + new_lines
else :
initial_lines = saved_lines
initial_cmd = saved_cmd
else :
initial_cmd = saved_cmd
initial_lines = saved_lines
session_state [ 'context_cmd' ] = max ( 1 , initial_cmd )
session_state [ 'context_lines' ] = max ( 1 , initial_lines )
session_state [ 'last_total_cmds' ] = total_cmds
session_state [ 'last_total_lines' ] = total_lines
node_info . update ( session_state )
node_info [ 'context_cmd' ] = min ( session_state [ 'context_cmd' ], max ( 1 , total_cmds ))
node_info [ 'context_lines' ] = min ( session_state [ 'context_lines' ], max ( 1 , total_lines ))
2026-05-11 12:30:43 -03:00
node_info_json = json . dumps ( node_info )
2026-05-12 12:20:50 -03:00
# Convert buffer to string if it's bytes for the preview
preview_str = buffer [ - 200 :] . decode ( errors = 'replace' ) if isinstance ( buffer , bytes ) else str ( buffer )[ - 200 :]
2026-05-15 16:25:18 -03:00
# Generate a unique session ID for this copilot interaction to prevent race conditions
import uuid
copilot_session_id = str ( uuid . uuid4 ())
node_info [ "session_id" ] = copilot_session_id
node_info_json = json . dumps ( node_info )
2026-05-08 18:45:42 -03:00
# 1. Send prompt to client
response_queue . put ( connpy_pb2 . InteractResponse (
copilot_prompt = True ,
2026-05-12 12:20:50 -03:00
copilot_buffer_preview = preview_str ,
2026-05-08 18:45:42 -03:00
copilot_node_info_json = node_info_json
))
2026-05-13 14:16:14 -03:00
while True :
2026-08-17 10:20:43 -03:00
# Refresh latest buffer from terminal log
raw_bytes = n . mylog . getvalue () if hasattr ( n , 'mylog' ) else buffer
if not isinstance ( raw_bytes , bytes ):
raw_bytes = str ( raw_bytes ) . encode ()
from connpy.utils import log_cleaner
cleaned_buffer = log_cleaner ( raw_bytes . decode ( errors = 'replace' ))
buffer = cleaned_buffer
2026-05-15 16:25:18 -03:00
# 0. Drain the queue of any stale messages before starting a new interaction
while not remote_stream . copilot_queue . empty ():
try :
remote_stream . copilot_queue . get_nowait ()
except :
break
2026-05-13 14:16:14 -03:00
# 2. Await the question from client via the copilot_queue
import threading
def preload_ai_deps ():
2026-05-11 12:30:43 -03:00
try :
2026-05-13 14:16:14 -03:00
import litellm
2026-05-11 12:30:43 -03:00
except Exception :
2026-05-13 14:16:14 -03:00
pass
threading . Thread ( target = preload_ai_deps , daemon = True ) . start ()
2026-05-08 18:45:42 -03:00
try :
2026-05-13 14:16:14 -03:00
req_data = await asyncio . wait_for ( remote_stream . copilot_queue . get (), timeout = 120 )
if not req_data : return
2026-05-15 16:25:18 -03:00
# Validate session ID if provided by client (skip validation if not provided for CLI compatibility)
req_session_id = req_data . get ( "session_id" )
if req_session_id and req_session_id != copilot_session_id :
continue # Ignore stale request from a previous session
2026-08-11 11:40:12 -03:00
merged_node_info_str = req_data . get ( "node_info_json" , "" )
if merged_node_info_str :
try :
merged_node_info = json . loads ( merged_node_info_str )
node_info . update ( merged_node_info )
# Sync context state from frontend into session_state for persistence
for k in ( 'context_mode' , 'context_cmd' , 'context_lines' ):
if k in merged_node_info :
session_state [ k ] = merged_node_info [ k ]
except : pass
2026-05-15 16:25:18 -03:00
if "question" not in req_data or not req_data [ "question" ] or req_data [ "question" ] == "CANCEL" or req_data . get ( "action" ) in ( "cancel" , "web_cancel" ):
if req_data . get ( "action" ) == "web_cancel" :
os . write ( child_fd , b ' \x05 ' )
else :
os . write ( child_fd , b ' \x15\r ' )
2026-05-13 14:16:14 -03:00
return
question = req_data [ "question" ]
context_buffer = req_data . get ( "context_buffer" , "" )
if context_buffer . startswith ( '{"context_start_pos"' ):
try :
parsed = json . loads ( context_buffer )
start_pos = parsed [ "context_start_pos" ]
selected_raw = raw_bytes [ start_pos :]
context_buffer = n . _logclean ( selected_raw . decode ( errors = 'replace' ), var = True )
except Exception :
context_buffer = buffer
elif not context_buffer :
context_buffer = buffer
except asyncio . TimeoutError :
2026-05-08 18:45:42 -03:00
os . write ( child_fd , b ' \x15\r ' )
2026-05-13 14:16:14 -03:00
return
# 3. Call AI Service with streaming
def chunk_callback ( chunk_text ):
if chunk_text :
response_queue . put ( connpy_pb2 . InteractResponse (
copilot_stream_chunk = chunk_text
))
# Create a clean version of node_info for the AI to save tokens and match local CLI behavior
ai_node_info = { k : v for k , v in node_info . items () if k not in ( "context_blocks" , "full_buffer" )}
ai_task = asyncio . create_task ( service . aask_copilot ( context_buffer , question , ai_node_info , chunk_callback = chunk_callback ))
wait_action_task = asyncio . create_task ( remote_stream . copilot_queue . get ())
done , pending = await asyncio . wait (
[ ai_task , wait_action_task ],
return_when = asyncio . FIRST_COMPLETED
)
if wait_action_task in done :
req_data = wait_action_task . result ()
ai_task . cancel ()
2026-05-15 16:25:18 -03:00
if req_data . get ( "action" ) in ( "cancel" , "web_cancel" ) or req_data . get ( "question" ) == "CANCEL" :
if req_data . get ( "action" ) == "web_cancel" :
os . write ( child_fd , b ' \x05 ' )
else :
os . write ( child_fd , b ' \x15\r ' )
2026-05-13 14:16:14 -03:00
return
continue # Loop back instead of returning to keep session alive
else :
wait_action_task . cancel ()
result = ai_task . result ()
if not result :
os . write ( child_fd , b ' \x15\r ' )
return
# 4. Send response back to client
response_queue . put ( connpy_pb2 . InteractResponse (
copilot_response_json = json . dumps ( result )
))
# 5. Wait for user action
try :
action_data = await asyncio . wait_for ( remote_stream . copilot_queue . get (), timeout = 60 )
if not action_data : return
action = action_data . get ( "action" , "cancel" )
2026-08-11 11:40:12 -03:00
merged_node_info_str = action_data . get ( "node_info_json" , "" )
if merged_node_info_str :
try :
merged_node_info = json . loads ( merged_node_info_str )
for k in ( 'context_mode' , 'context_cmd' , 'context_lines' ):
if k in merged_node_info :
session_state [ k ] = merged_node_info [ k ]
except : pass
2026-05-13 14:16:14 -03:00
if action == "continue" :
continue # Loop back for next question
2026-05-15 16:25:18 -03:00
if action in ( "cancel" , "web_cancel" ):
if action == "web_cancel" :
os . write ( child_fd , b ' \x05 ' )
else :
os . write ( child_fd , b ' \x15\r ' )
2026-05-13 14:16:14 -03:00
return
except asyncio . TimeoutError :
os . write ( child_fd , b ' \x15\r ' )
return
2026-05-15 16:25:18 -03:00
def on_inject ( cmd ):
response_queue . put ( connpy_pb2 . InteractResponse ( copilot_injected_command = cmd ))
2026-05-13 14:16:14 -03:00
if action == "send_all" :
commands = result . get ( "commands" , [])
2026-05-15 16:25:18 -03:00
await n . inject_commands ( commands , child_fd , on_inject = on_inject )
2026-05-13 14:16:14 -03:00
elif action . startswith ( "custom:" ):
2026-05-15 16:25:18 -03:00
custom_cmds_raw = action [ 7 :]
custom_cmds = [ cmd . strip () for cmd in custom_cmds_raw . split ( ' \n ' ) if cmd . strip ()]
await n . inject_commands ( custom_cmds , child_fd , on_inject = on_inject )
2026-05-13 14:16:14 -03:00
else :
os . write ( child_fd , b ' \x15\r ' )
return
2026-05-08 18:45:42 -03:00
2026-08-17 10:20:43 -03:00
# Dynamic Wait for Device Prompt Settle
prompt_pattern = node_info . get ( "prompt" , r '>$|#$|\$$|>.$|#.$|\$.$' )
import time
import re
start_t = time . time ()
last_len = 0
quiet_count = 0
while time . time () - start_t < 60 :
await asyncio . sleep ( 0.15 )
cur_bytes = n . mylog . getvalue ()
if len ( cur_bytes ) == last_len :
quiet_count += 1
else :
quiet_count = 0
last_len = len ( cur_bytes )
clean_txt = n . _logclean ( cur_bytes . decode ( errors = 'replace' ), True ) . strip ()
lines = [ l . strip () for l in clean_txt . split ( ' \n ' ) if l . strip ()]
last_line = lines [ - 1 ] if lines else ""
if quiet_count >= 2 and re . search ( prompt_pattern , last_line ):
break
# Recalculate context blocks with updated buffer
raw_bytes = n . mylog . getvalue ()
from connpy.utils import log_cleaner
cleaned_buffer = log_cleaner ( raw_bytes . decode ( errors = 'replace' ))
last_line = cleaned_buffer . split ( ' \n ' )[ - 1 ] . strip () if cleaned_buffer . strip () else "(prompt)"
blocks = service . build_context_blocks ( raw_bytes , n . cmd_byte_positions , node_info , last_line = last_line )
node_info [ "context_blocks" ] = blocks
total_cmds = len ( blocks )
total_lines = len ( cleaned_buffer . split ( ' \n ' ))
last_total_cmds = session_state . get ( 'last_total_cmds' , None )
saved_cmd = session_state . get ( 'context_cmd' , 1 )
is_mission = session_state . get ( 'mission' , {}) . get ( 'active' , False ) or ( isinstance ( node_info , dict ) and node_info . get ( 'mission' , {}) . get ( 'active' , False ))
if last_total_cmds is not None and total_cmds > last_total_cmds and ( saved_cmd > 1 or is_mission ):
new_cmds = total_cmds - last_total_cmds
initial_cmd = saved_cmd + new_cmds
else :
initial_cmd = saved_cmd
session_state [ 'context_cmd' ] = max ( 1 , initial_cmd )
session_state [ 'last_total_cmds' ] = total_cmds
session_state [ 'last_total_lines' ] = total_lines
node_info [ 'context_cmd' ] = min ( session_state [ 'context_cmd' ], max ( 1 , total_cmds ))
node_info [ 'context_lines' ] = min ( session_state . get ( 'context_lines' , 50 ), max ( 1 , total_lines ))
node_info_json = json . dumps ( node_info )
preview_str = raw_bytes [ - 200 :] . decode ( errors = 'replace' ) if isinstance ( raw_bytes , bytes ) else str ( raw_bytes )[ - 200 :]
# Signal prompt settle and send updated blocks to client
response_queue . put ( connpy_pb2 . InteractResponse (
copilot_prompt = True ,
copilot_buffer_preview = preview_str ,
copilot_node_info_json = node_info_json
))
continue
2026-05-08 18:45:42 -03:00
asyncio . run ( n . _async_interact_loop ( remote_stream , resize_callback , copilot_handler = remote_copilot_handler ))
2026-04-27 15:12:07 -03:00
except Exception as e :
2026-05-19 16:23:35 -03:00
import traceback
print ( f "[ERROR in run_async_loop] { e } " )
traceback . print_exc ()
2026-04-27 15:12:07 -03:00
finally :
n . _teardown_interact_environment ()
response_queue . put ( None ) # Signal EOF
t_loop = threading . Thread ( target = run_async_loop , daemon = True )
t_loop . start ()
2026-05-08 18:45:42 -03:00
def response_generator ():
while True :
data = response_queue . get ()
if data is None :
if self . server_debug :
self . server_console . print ( f "[debug][DEBUG][/debug] gRPC interact_node session closed for: [bold cyan] { unique_id } [/bold cyan]" )
break
if isinstance ( data , connpy_pb2 . InteractResponse ):
yield data
else :
yield connpy_pb2 . InteractResponse ( stdout_data = data )
yield from response_generator ()
2026-04-27 15:12:07 -03:00
2026-04-17 18:42:08 -03:00
@handle_errors
def list_nodes ( self , request , context ):
f = request . filter_str if request . filter_str else None
fmt = request . format_str if request . format_str else None
return connpy_pb2 . ValueResponse ( data = to_value ( self . service . list_nodes ( f , fmt )))
@handle_errors
def list_folders ( self , request , context ):
f = request . filter_str if request . filter_str else None
return connpy_pb2 . ValueResponse ( data = to_value ( self . service . list_folders ( f )))
@handle_errors
def get_node_details ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . get_node_details ( request . id )))
@handle_errors
def explode_unique ( self , request , context ):
return connpy_pb2 . ValueResponse ( data = to_value ( self . service . explode_unique ( request . id )))
2026-04-24 19:23:00 -03:00
@handle_errors
def validate_parent_folder ( self , request , context ):
self . service . validate_parent_folder ( request . id )
return Empty ()
2026-04-17 18:42:08 -03:00
@handle_errors
def generate_cache ( self , request , context ):
self . service . generate_cache ()
return Empty ()
@handle_errors
def add_node ( self , request , context ):
self . service . add_node ( request . id , from_struct ( request . data ), request . is_folder )
self . service . generate_cache ()
return Empty ()
@handle_errors
def update_node ( self , request , context ):
self . service . update_node ( request . id , from_struct ( request . data ))
self . service . generate_cache ()
return Empty ()
@handle_errors
def delete_node ( self , request , context ):
self . service . delete_node ( request . id , request . is_folder )
self . service . generate_cache ()
return Empty ()
@handle_errors
def move_node ( self , request , context ):
self . service . move_node ( request . src_id , request . dst_id , request . copy )
self . service . generate_cache ()
return Empty ()
@handle_errors
def bulk_add ( self , request , context ):
self . service . bulk_add ( list ( request . ids ), list ( request . hosts ), from_struct ( request . common_data ))
self . service . generate_cache ()
return Empty ()
@handle_errors
def set_reserved_names ( self , request , context ):
self . service . set_reserved_names ( list ( request . items ))
self . service . generate_cache ()
return Empty ()
@handle_errors
def full_replace ( self , request , context ):
connections = from_struct ( request . connections )
profiles = from_struct ( request . profiles )
self . service . full_replace ( connections , profiles )
self . service . generate_cache ()
return Empty ()
@handle_errors
def get_inventory ( self , request , context ):
data = self . service . get_inventory ()
return connpy_pb2 . FullReplaceRequest (
connections = to_struct ( data [ "connections" ]),
profiles = to_struct ( data [ "profiles" ])
)
class ProfileServicer ( connpy_pb2_grpc . ProfileServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
2026-04-17 18:42:08 -03:00
2026-05-28 09:27:54 -03:00
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . profiles
@property
def node_service ( self ):
return self . _get_provider () . nodes
2026-05-20 12:27:02 -03:00
2026-04-17 18:42:08 -03:00
@handle_errors
def list_profiles ( self , request , context ):
f = request . filter_str if request . filter_str else None
return connpy_pb2 . ValueResponse ( data = to_value ( self . service . list_profiles ( f )))
@handle_errors
def get_profile ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . get_profile ( request . name , request . resolve )))
@handle_errors
def add_profile ( self , request , context ):
self . service . add_profile ( request . id , from_struct ( request . data ))
self . node_service . generate_cache ()
return Empty ()
@handle_errors
def resolve_node_data ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . resolve_node_data ( from_struct ( request . data ))))
@handle_errors
def delete_profile ( self , request , context ):
self . service . delete_profile ( request . id )
self . node_service . generate_cache ()
return Empty ()
@handle_errors
def update_profile ( self , request , context ):
self . service . update_profile ( request . id , from_struct ( request . data ))
self . node_service . generate_cache ()
return Empty ()
class ConfigServicer ( connpy_pb2_grpc . ConfigServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . config_svc
2026-04-17 18:42:08 -03:00
@handle_errors
def get_settings ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . get_settings ()))
@handle_errors
def get_default_dir ( self , request , context ):
return connpy_pb2 . StringResponse ( value = self . service . get_default_dir ())
@handle_errors
def set_config_folder ( self , request , context ):
self . service . set_config_folder ( request . value )
return Empty ()
@handle_errors
def update_setting ( self , request , context ):
self . service . update_setting ( request . key , from_value ( request . value ))
return Empty ()
@handle_errors
def encrypt_password ( self , request , context ):
return connpy_pb2 . StringResponse ( value = self . service . encrypt_password ( request . value ))
@handle_errors
def apply_theme_from_file ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . apply_theme_from_file ( request . value )))
class PluginServicer ( connpy_pb2_grpc . PluginServiceServicer , remote_plugin_pb2_grpc . RemotePluginServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . plugins
2026-04-17 18:42:08 -03:00
@handle_errors
def list_plugins ( self , request , context ):
return connpy_pb2 . ValueResponse ( data = to_value ( self . service . list_plugins ()))
@handle_errors
def add_plugin ( self , request , context ):
if request . source_file . startswith ( "---CONTENT--- \n " ):
content = request . source_file [ len ( "---CONTENT--- \n " ):] . encode ()
self . service . add_plugin_from_bytes ( request . name , content , request . update )
else :
self . service . add_plugin ( request . name , request . source_file , request . update )
return Empty ()
@handle_errors
def delete_plugin ( self , request , context ):
self . service . delete_plugin ( request . id )
return Empty ()
@handle_errors
def enable_plugin ( self , request , context ):
self . service . enable_plugin ( request . id )
return Empty ()
@handle_errors
def disable_plugin ( self , request , context ):
self . service . disable_plugin ( request . id )
return Empty ()
@handle_errors
def get_plugin_source ( self , request , context ):
source = self . service . get_plugin_source ( request . id )
return remote_plugin_pb2 . StringResponse ( value = source )
@handle_errors
def invoke_plugin ( self , request , context ):
args_dict = json . loads ( request . args_json )
for chunk in self . service . invoke_plugin ( request . name , args_dict ):
yield remote_plugin_pb2 . OutputChunk ( text = chunk )
class ExecutionServicer ( connpy_pb2_grpc . ExecutionServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . execution
2026-04-17 18:42:08 -03:00
@handle_errors
def run_commands ( self , request , context ):
import queue
import threading
nodes_filter = request . nodes [ 0 ] if len ( request . nodes ) == 1 else list ( request . nodes )
2026-05-28 09:27:54 -03:00
# Resolve provider in the main gRPC thread where _current_user ContextVar is set.
# threading.Thread does NOT inherit ContextVars, so self.service inside
# _worker() would fall back to the admin provider.
execution_service = self . service
2026-04-17 18:42:08 -03:00
q = queue . Queue ()
def _on_complete ( unique , output , status ):
q . put ({ "unique_id" : unique , "output" : output , "status" : status })
def _worker ():
try :
2026-05-28 09:27:54 -03:00
execution_service . run_commands ( nodes_filter = nodes_filter ,
2026-04-17 18:42:08 -03:00
commands = list ( request . commands ),
folder = request . folder if request . folder else None ,
prompt = request . prompt if request . prompt else None ,
parallel = request . parallel ,
2026-04-30 14:18:41 -03:00
timeout = request . timeout if request . timeout > 0 else 10 ,
2026-04-17 18:42:08 -03:00
variables = from_struct ( request . vars ) if request . HasField ( "vars" ) else None ,
2026-04-30 14:18:41 -03:00
on_node_complete = _on_complete ,
name = request . name if request . name else None
2026-04-17 18:42:08 -03:00
)
except Exception as e :
# Optionally pass error to stream, but handle_errors decorator covers top-level.
# However, thread exceptions won't reach context.abort directly.
q . put ( e )
finally :
q . put ( None )
2026-06-03 16:49:52 -03:00
import contextvars
ctx = contextvars . copy_context ()
threading . Thread ( target = lambda : ctx . run ( _worker ), daemon = True ) . start ()
2026-04-17 18:42:08 -03:00
while True :
item = q . get ()
if item is None :
break
if isinstance ( item , Exception ):
raise item
yield connpy_pb2 . NodeRunResult (
unique_id = item [ "unique_id" ],
output = item [ "output" ],
status = item [ "status" ]
)
@handle_errors
def test_commands ( self , request , context ):
import queue
import threading
nodes_filter = request . nodes [ 0 ] if len ( request . nodes ) == 1 else list ( request . nodes )
2026-05-28 09:27:54 -03:00
# Resolve provider in the main gRPC thread where _current_user ContextVar is set.
execution_service = self . service
2026-04-17 18:42:08 -03:00
q = queue . Queue ()
2026-04-30 14:18:41 -03:00
def _on_complete ( unique , node_output , node_status , node_result ):
q . put ({ "unique_id" : unique , "output" : node_output , "status" : node_status , "result" : node_result })
2026-04-17 18:42:08 -03:00
def _worker ():
try :
2026-05-28 09:27:54 -03:00
execution_service . test_commands (
2026-04-17 18:42:08 -03:00
nodes_filter = nodes_filter ,
commands = list ( request . commands ),
2026-04-30 14:18:41 -03:00
expected = list ( request . expected ),
2026-04-17 18:42:08 -03:00
folder = request . folder if request . folder else None ,
prompt = request . prompt if request . prompt else None ,
parallel = request . parallel ,
2026-04-30 14:18:41 -03:00
timeout = request . timeout if request . timeout > 0 else 10 ,
2026-04-17 18:42:08 -03:00
variables = from_struct ( request . vars ) if request . HasField ( "vars" ) else None ,
2026-04-30 14:18:41 -03:00
on_node_complete = _on_complete ,
name = request . name if request . name else None
2026-04-17 18:42:08 -03:00
)
except Exception as e :
q . put ( e )
finally :
q . put ( None )
2026-06-03 16:49:52 -03:00
import contextvars
ctx = contextvars . copy_context ()
threading . Thread ( target = lambda : ctx . run ( _worker ), daemon = True ) . start ()
2026-04-17 18:42:08 -03:00
while True :
item = q . get ()
if item is None :
break
if isinstance ( item , Exception ):
raise item
res = connpy_pb2 . NodeRunResult (
unique_id = item [ "unique_id" ],
output = item [ "output" ],
status = item [ "status" ]
)
if item [ "result" ] is not None :
res . test_result . CopyFrom ( to_struct ( item [ "result" ]))
yield res
@handle_errors
def run_cli_script ( self , request , context ):
res = self . service . run_cli_script ( request . param1 , request . param2 , request . parallel )
return connpy_pb2 . StructResponse ( data = to_struct ( res ))
class ImportExportServicer ( connpy_pb2_grpc . ImportExportServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . import_export
@property
def node_service ( self ):
return self . _get_provider () . nodes
2026-04-17 18:42:08 -03:00
@handle_errors
def export_to_file ( self , request , context ):
self . service . export_to_file ( request . file_path , list ( request . folders ) if request . folders else None )
return Empty ()
@handle_errors
def import_from_file ( self , request , context ):
if request . value . startswith ( "---YAML--- \n " ):
import yaml
content = request . value [ len ( "---YAML--- \n " ):]
data = yaml . load ( content , Loader = yaml . FullLoader )
self . service . import_from_dict ( data )
else :
self . service . import_from_file ( request . value )
self . node_service . generate_cache ()
return Empty ()
@handle_errors
def set_reserved_names ( self , request , context ):
self . service . set_reserved_names ( list ( request . items ))
self . node_service . generate_cache ()
return Empty ()
class StatusBridge :
2026-04-24 19:23:00 -03:00
def __init__ ( self , q , request_queue = None , is_web = False ):
2026-04-17 18:42:08 -03:00
self . q = q
self . request_queue = request_queue
self . on_interrupt = self . _force_interrupt
self . thread = None
2026-04-24 19:23:00 -03:00
self . is_web = is_web
2026-05-20 12:27:02 -03:00
self . is_remote = True
2026-04-17 18:42:08 -03:00
def _force_interrupt ( self ):
"""Forcefully raise KeyboardInterrupt in the target thread."""
if self . thread and self . thread . ident :
# Standard Python trick to raise an exception in a specific thread
2026-04-24 19:23:00 -03:00
import ctypes
2026-04-17 18:42:08 -03:00
ctypes . pythonapi . PyThreadState_SetAsyncExc (
ctypes . c_long ( self . thread . ident ),
ctypes . py_object ( KeyboardInterrupt )
)
def update ( self , msg ):
self . q . put (( "status" , msg ))
def stop ( self ):
pass
def print ( self , * args , ** kwargs ):
# Capture Rich output and send as debug message
self . _print_to_queue ( "debug" , * args , ** kwargs )
def print_important ( self , * args , ** kwargs ):
# Capture Rich output and send as important message (always show)
self . _print_to_queue ( "important" , * args , ** kwargs )
def _print_to_queue ( self , msg_type , * args , ** kwargs ):
from rich.console import Console
2026-04-24 19:23:00 -03:00
from rich.panel import Panel
2026-04-17 18:42:08 -03:00
from io import StringIO
from ..printer import connpy_theme
2026-04-24 19:23:00 -03:00
processed_args = list ( args )
if self . is_web :
# Remove Panels to avoid box characters on web, but preserve Title
processed_args = []
for arg in args :
if isinstance ( arg , Panel ):
# If it has a title, prepend it to the content to allow detection
content = arg . renderable
if arg . title :
processed_args . append ( f " { arg . title } \n " )
processed_args . append ( content )
else :
processed_args . append ( arg )
2026-04-17 18:42:08 -03:00
buf = StringIO ()
2026-04-24 19:23:00 -03:00
# force_terminal=False removes ANSI escape codes for Web
c = Console ( file = buf , force_terminal = not self . is_web , width = 100 , theme = connpy_theme )
c . print ( * processed_args , ** kwargs )
text_content = buf . getvalue () . strip ()
if text_content :
self . q . put (( msg_type , text_content ))
2026-04-17 18:42:08 -03:00
def confirm ( self , prompt , default = "n" ):
"""Bridge confirmation to the gRPC client."""
if not self . request_queue :
return default
# Render markup to ANSI for the client
from rich.console import Console
from io import StringIO
from ..printer import connpy_theme
buf = StringIO ()
c = Console ( file = buf , force_terminal = True , theme = connpy_theme )
c . print ( prompt , end = "" )
ansi_prompt = buf . getvalue ()
# Send confirmation request to client
self . q . put (( "confirm" , ansi_prompt ))
# Wait for the client to send back the answer via the request stream
try :
# Block until we get the next request from the client
req = self . request_queue . get ()
if req and req . confirmation_answer :
return req . confirmation_answer
except Exception :
pass
return default
class AIServicer ( connpy_pb2_grpc . AIServiceServicer ):
2026-05-28 10:47:21 -03:00
def __init__ ( self , provider , registry = None , debug = False ):
2026-05-28 09:27:54 -03:00
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
2026-05-28 10:35:15 -03:00
self . server_debug = debug
if debug :
from rich.console import Console
from ..printer import connpy_theme , get_original_stdout
self . server_console = Console ( theme = connpy_theme , file = get_original_stdout ())
2026-05-28 09:27:54 -03:00
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . ai
2026-04-17 18:42:08 -03:00
2026-06-01 17:49:19 -03:00
def _handle_chat_stream ( self , request_iterator , context , service_method ):
2026-04-17 18:42:08 -03:00
import queue
import threading
2026-06-03 16:49:52 -03:00
import contextvars
2026-04-17 18:42:08 -03:00
chunk_queue = queue . Queue ()
request_queue = queue . Queue ()
2026-04-24 19:23:00 -03:00
bridge = None
history = []
is_web = False
2026-04-17 18:42:08 -03:00
2026-04-24 19:23:00 -03:00
# Dedicated event to signal AI thread to stop
ai_thread = None
agent_instance = None
2026-04-17 18:42:08 -03:00
def callback ( chunk ):
chunk_queue . put (( "text" , chunk ))
2026-04-24 19:23:00 -03:00
def run_ai_task ( input_text , session_id , debug , overrides , trust ):
nonlocal history , bridge , agent_instance
2026-04-17 18:42:08 -03:00
try :
2026-04-24 19:23:00 -03:00
# Run the AI interaction (this blocks this specific thread)
2026-06-01 17:49:19 -03:00
if getattr ( service_method , "__name__" , None ) == "build_playbook_chat" :
res = service_method (
input_text ,
chat_history = history if history else None ,
status = bridge ,
chunk_callback = callback
)
else :
res = service_method (
input_text ,
chat_history = history if history else None ,
session_id = session_id ,
debug = debug ,
status = bridge ,
2026-06-03 16:49:52 -03:00
console = bridge ,
2026-06-01 17:49:19 -03:00
confirm_handler = bridge . confirm ,
chunk_callback = callback ,
trust = trust ,
** overrides
)
2026-04-24 19:23:00 -03:00
# Update history for next message
2026-06-01 17:49:19 -03:00
if res and "chat_history" in res :
2026-04-24 19:23:00 -03:00
history = res [ "chat_history" ]
# Send final chunk marker
chunk_queue . put (( "final_mark" , res ))
2026-05-28 10:35:15 -03:00
except ValueError as e :
# Configuration or LLM provider connection errors are expected, only print in debug mode
if debug or getattr ( self , "server_debug" , False ):
from rich.console import Console
from ..printer import connpy_theme , get_original_stdout
c = getattr ( self , "server_console" , None ) or Console ( theme = connpy_theme , file = get_original_stdout ())
c . print ( f "[debug][DEBUG][/debug] AI Task Error: { e } " )
chunk_queue . put (( "status" , f "Error: { str ( e ) } " ))
# Crucial: always send final_mark to avoid client deadlock
chunk_queue . put (( "final_mark" , { "response" : f "Error: { str ( e ) } " , "chat_history" : history , "error" : True }))
2026-04-17 18:42:08 -03:00
except Exception as e :
2026-04-24 19:23:00 -03:00
import traceback
print ( f "AI Task Error: { e } " )
traceback . print_exc ()
chunk_queue . put (( "status" , f "Error: { str ( e ) } " ))
2026-05-20 12:27:02 -03:00
# Crucial: always send final_mark to avoid client deadlock
chunk_queue . put (( "final_mark" , { "response" : f "Error: { str ( e ) } " , "chat_history" : history , "error" : True }))
2026-04-24 19:23:00 -03:00
def request_listener ():
2026-05-20 12:27:02 -03:00
nonlocal bridge , is_web , ai_thread , agent_instance , history
2026-04-24 19:23:00 -03:00
try :
for req in request_iterator :
if req . interrupt :
if bridge and bridge . on_interrupt :
bridge . on_interrupt ()
continue
if req . confirmation_answer :
request_queue . put ( req )
continue
if req . input_text :
is_web = "web" in ( req . session_id or "" ) . lower () or ( req . session_id or "" ) . lower () . startswith ( "ws-" )
2026-05-20 12:27:02 -03:00
# Hydrate history from client if it's the first interaction in this stream
if not history and req . chat_history :
from .utils import from_value
history = from_value ( req . chat_history ) or []
2026-04-24 19:23:00 -03:00
if not bridge :
bridge = StatusBridge ( chunk_queue , request_queue = request_queue , is_web = is_web )
overrides = {}
if req . engineer_model : overrides [ "engineer_model" ] = req . engineer_model
if req . engineer_api_key : overrides [ "engineer_api_key" ] = req . engineer_api_key
2026-05-21 18:20:24 -03:00
if req . architect_model : overrides [ "architect_model" ] = req . architect_model
if req . architect_api_key : overrides [ "architect_api_key" ] = req . architect_api_key
if req . HasField ( "engineer_auth" ): overrides [ "engineer_auth" ] = from_struct ( req . engineer_auth )
if req . HasField ( "architect_auth" ): overrides [ "architect_auth" ] = from_struct ( req . architect_auth )
2026-04-24 19:23:00 -03:00
2026-06-03 16:49:52 -03:00
# Start AI in its own thread with a fresh copy of context so we can keep listening for interrupts
ctx_ai = contextvars . copy_context ()
2026-04-24 19:23:00 -03:00
ai_thread = threading . Thread (
2026-06-03 16:49:52 -03:00
target = lambda : ctx_ai . run ( run_ai_task , req . input_text , req . session_id , req . debug , overrides , req . trust ),
2026-04-24 19:23:00 -03:00
daemon = True
)
ai_thread . start ()
2026-04-27 15:12:07 -03:00
except grpc . RpcError :
pass
2026-04-24 19:23:00 -03:00
except Exception as e :
print ( f "Request Listener Error: { e } " )
2026-04-17 18:42:08 -03:00
finally :
2026-04-24 19:23:00 -03:00
# When client closes stream, send sentinel
chunk_queue . put (( None , None ))
2026-04-17 18:42:08 -03:00
2026-06-03 16:49:52 -03:00
# Start listening for client requests/signals with a copied context
ctx_listener = contextvars . copy_context ()
threading . Thread ( target = lambda : ctx_listener . run ( request_listener ), daemon = True ) . start ()
2026-04-17 18:42:08 -03:00
2026-04-24 19:23:00 -03:00
# Main response loop (yields to gRPC)
2026-04-17 18:42:08 -03:00
while True :
item = chunk_queue . get ()
2026-04-24 19:23:00 -03:00
if item == ( None , None ):
2026-04-17 18:42:08 -03:00
break
2026-04-24 19:23:00 -03:00
2026-04-17 18:42:08 -03:00
msg_type , val = item
if msg_type == "text" :
yield connpy_pb2 . AIResponse ( text_chunk = val , is_final = False )
elif msg_type == "status" :
2026-04-24 19:23:00 -03:00
if is_web and "is thinking" in val . lower (): continue
clean_val = val . replace ( "[ai_status]" , "" ) . replace ( "[/ai_status]" , "" )
yield connpy_pb2 . AIResponse ( status_update = clean_val , is_final = False )
2026-04-17 18:42:08 -03:00
elif msg_type == "debug" :
yield connpy_pb2 . AIResponse ( debug_message = val , is_final = False )
elif msg_type == "important" :
yield connpy_pb2 . AIResponse ( important_message = val , is_final = False )
elif msg_type == "confirm" :
yield connpy_pb2 . AIResponse ( status_update = val , requires_confirmation = True , is_final = False )
2026-04-24 19:23:00 -03:00
elif msg_type == "final_mark" :
yield connpy_pb2 . AIResponse ( is_final = True , full_result = to_struct ( val ))
2026-04-17 18:42:08 -03:00
2026-06-01 17:49:19 -03:00
def _handle_unary_stream ( self , service_method , * args , ** kwargs ):
import queue
import threading
chunk_queue = queue . Queue ()
bridge = StatusBridge ( chunk_queue , is_web = False )
def callback ( chunk ):
chunk_queue . put (( "text" , chunk ))
def _worker ():
try :
res = service_method ( * args , chunk_callback = callback , status = bridge , ** kwargs )
chunk_queue . put (( "final_mark" , res ))
except Exception as e :
import traceback
print ( f "gRPC Unary Stream error: { e } " )
traceback . print_exc ()
chunk_queue . put (( "status" , f "Error: { str ( e ) } " ))
chunk_queue . put (( "final_mark" , { "response" : f "Error: { str ( e ) } " , "error" : True }))
finally :
chunk_queue . put (( None , None ))
2026-06-03 16:49:52 -03:00
import contextvars
ctx = contextvars . copy_context ()
threading . Thread ( target = lambda : ctx . run ( _worker ), daemon = True ) . start ()
2026-06-01 17:49:19 -03:00
while True :
item = chunk_queue . get ()
if item == ( None , None ):
break
msg_type , val = item
if msg_type == "text" :
yield connpy_pb2 . AIResponse ( text_chunk = val , is_final = False )
elif msg_type == "status" :
clean_val = val . replace ( "[ai_status]" , "" ) . replace ( "[/ai_status]" , "" )
yield connpy_pb2 . AIResponse ( status_update = clean_val , is_final = False )
elif msg_type == "debug" :
yield connpy_pb2 . AIResponse ( debug_message = val , is_final = False )
elif msg_type == "important" :
yield connpy_pb2 . AIResponse ( important_message = val , is_final = False )
elif msg_type == "confirm" :
yield connpy_pb2 . AIResponse ( status_update = val , requires_confirmation = True , is_final = False )
elif msg_type == "final_mark" :
yield connpy_pb2 . AIResponse ( is_final = True , full_result = to_struct ( val ))
@handle_errors
def ask ( self , request_iterator , context ):
yield from self . _handle_chat_stream ( request_iterator , context , self . service . ask )
@handle_errors
def build_playbook_chat ( self , request_iterator , context ):
yield from self . _handle_chat_stream ( request_iterator , context , self . service . build_playbook_chat )
@handle_errors
def analyze_execution_results ( self , request , context ):
results = from_struct ( request . results )
query = request . query if request . query else None
yield from self . _handle_unary_stream ( self . service . analyze_execution_results , results , query = query )
@handle_errors
def predict_execution_results ( self , request , context ):
target_nodes = list ( request . target_nodes )
commands = list ( request . commands )
yield from self . _handle_unary_stream ( self . service . predict_execution_results , target_nodes , commands )
2026-04-17 18:42:08 -03:00
@handle_errors
def confirm ( self , request , context ):
res = self . service . confirm ( request . value )
return connpy_pb2 . BoolResponse ( value = res )
2026-05-07 15:17:00 -03:00
@handle_errors
def ask_copilot ( self , request , context ):
import json
node_info = json . loads ( request . node_info_json ) if request . node_info_json else None
result = self . service . ask_copilot (
request . terminal_buffer ,
request . user_question ,
node_info
)
return connpy_pb2 . CopilotResponse (
commands = result . get ( "commands" , []),
guide = result . get ( "guide" , "" ),
risk_level = result . get ( "risk_level" , "low" ),
error = result . get ( "error" ) or ""
)
2026-04-17 18:42:08 -03:00
@handle_errors
def list_sessions ( self , request , context ):
2026-05-20 12:27:02 -03:00
sessions , total = self . service . list_sessions ()
return connpy_pb2 . ValueResponse ( data = to_value ( sessions ))
2026-04-17 18:42:08 -03:00
@handle_errors
def delete_session ( self , request , context ):
self . service . delete_session ( request . value )
return Empty ()
@handle_errors
def configure_provider ( self , request , context ):
2026-05-21 18:20:24 -03:00
auth_dict = from_struct ( request . auth ) if request . HasField ( "auth" ) else None
self . service . configure_provider ( request . provider , request . model , request . api_key , auth = auth_dict )
2026-04-17 18:42:08 -03:00
return Empty ()
2026-05-12 12:20:50 -03:00
@handle_errors
def configure_mcp ( self , request , context ):
self . service . configure_mcp (
request . name ,
url = request . url or None ,
enabled = request . enabled ,
auto_load_on_os = request . auto_load_on_os or None ,
remove = request . remove
)
return Empty ()
2026-04-17 18:42:08 -03:00
2026-05-20 12:27:02 -03:00
@handle_errors
def list_mcp_servers ( self , request , context ):
mcp_servers = self . service . list_mcp_servers ()
return connpy_pb2 . ValueResponse ( data = to_value ( mcp_servers ))
2026-04-17 18:42:08 -03:00
@handle_errors
def load_session_data ( self , request , context ):
return connpy_pb2 . StructResponse ( data = to_struct ( self . service . load_session_data ( request . value )))
class SystemServicer ( connpy_pb2_grpc . SystemServiceServicer ):
2026-05-28 09:27:54 -03:00
def __init__ ( self , provider , registry = None ):
if not hasattr ( provider , "mode" ):
from connpy.services.provider import ServiceProvider
provider = ServiceProvider ( provider , mode = "local" )
self . _fallback_provider = provider
self . _registry = registry
def _get_provider ( self ):
if self . _registry :
username = _current_user . get ()
if username :
return self . _registry . get_provider ( username )
return self . _fallback_provider
@property
def service ( self ):
return self . _get_provider () . system
2026-04-17 18:42:08 -03:00
@handle_errors
def start_api ( self , request , context ):
self . service . start_api ( request . value )
return Empty ()
@handle_errors
def debug_api ( self , request , context ):
self . service . debug_api ( request . value )
return Empty ()
@handle_errors
def stop_api ( self , request , context ):
self . service . stop_api ()
return Empty ()
@handle_errors
def restart_api ( self , request , context ):
self . service . restart_api ( request . value )
return Empty ()
@handle_errors
def get_api_status ( self , request , context ):
return connpy_pb2 . BoolResponse ( value = self . service . get_api_status ())
2026-05-28 09:27:54 -03:00
class AuthServicer ( connpy_pb2_grpc . AuthServiceServicer ):
def __init__ ( self , registry ):
self . registry = registry
@handle_errors
def login ( self , request , context ):
username = request . username
password = request . password
if not self . registry . user_service . authenticate ( username , password ):
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Invalid username or password" )
token = self . registry . user_service . generate_jwt ( username )
2026-06-04 18:33:26 -03:00
expires_at = int (( datetime . datetime . now ( datetime . timezone . utc ) + datetime . timedelta ( hours = 12 )) . timestamp ())
2026-05-28 09:27:54 -03:00
return connpy_pb2 . LoginResponse (
token = token ,
username = username ,
expires_at = expires_at
)
2026-06-04 18:33:26 -03:00
@handle_errors
def login_sso ( self , request , context ):
username = request . username
id_token = request . id_token
provider = request . provider
if not id_token or not provider :
context . abort ( grpc . StatusCode . INVALID_ARGUMENT , "id_token and provider are required" )
# Load SSO configuration
sso_config = {}
if self . registry :
shared_config = self . registry . get_shared_config ()
if shared_config :
sso_config = shared_config . config . get ( "sso" , {})
providers = sso_config . get ( "providers" , {})
if provider not in providers :
context . abort ( grpc . StatusCode . FAILED_PRECONDITION , f "SSO Provider ' { provider } ' not configured in config.yaml" )
p_config = providers [ provider ]
jwks_url = p_config . get ( "jwks_url" )
secret = p_config . get ( "secret" )
if secret and secret . startswith ( "$" ):
import os
secret = os . getenv ( secret [ 1 :])
if not jwks_url and not secret :
context . abort ( grpc . StatusCode . FAILED_PRECONDITION , f "Provider ' { provider } ' has no jwks_url or secret configured" )
# Validate token
import jwt
try :
algorithms = p_config . get ( "algorithms" , [ "RS256" ] if jwks_url else [ "HS256" ])
verify_aud = "audience" in p_config
audience = p_config . get ( "audience" )
verify_iss = "issuer" in p_config
issuer = p_config . get ( "issuer" )
options = {
"verify_signature" : True ,
"verify_exp" : True ,
"verify_aud" : verify_aud ,
"verify_iss" : verify_iss
}
decode_kwargs = {
"algorithms" : algorithms ,
"options" : options
}
if verify_aud :
decode_kwargs [ "audience" ] = audience
if verify_iss :
decode_kwargs [ "issuer" ] = issuer
if jwks_url :
from jwt import PyJWKClient
jwks_client = PyJWKClient ( jwks_url )
signing_key = jwks_client . get_signing_key_from_jwt ( id_token )
payload = jwt . decode ( id_token , signing_key . key , ** decode_kwargs )
else :
payload = jwt . decode ( id_token , secret , ** decode_kwargs )
except Exception as e :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , f "SSO Token validation failed: { str ( e ) } " )
# Extract username from claim
username_claim = p_config . get ( "username_claim" , "sub" )
claim_username = payload . get ( username_claim )
if not claim_username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , f "Username claim ' { username_claim } ' not found in SSO Token" )
# Check domain restrictions (allowed_domains)
allowed_domains = p_config . get ( "allowed_domains" , [])
if allowed_domains :
email = payload . get ( "email" )
if not email and claim_username and "@" in claim_username :
email = claim_username
if not email :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Domain restriction enabled but no email claim found in SSO Token" )
try :
user_domain = email . split ( "@" )[ - 1 ] . strip () . lower ()
except Exception :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , f "Invalid email format in SSO Token: ' { email } '" )
allowed_domains_lower = [ d . strip () . lower () for d in allowed_domains if d ]
if user_domain not in allowed_domains_lower :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , f "SSO user domain ' { user_domain } ' not allowed" )
# Normalize username to alphanumeric/dashes/underscores to match connpy's username regex
import re
normalized_username = re . sub ( r '[^a-zA-Z0-9_-]' , '_' , claim_username . split ( '@' )[ 0 ])
# If a requested username was sent, verify it matches
if username and username != normalized_username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , f "Mismatched username. Expected ' { normalized_username } ', got ' { username } '" )
# Check if user exists in connpy registry, otherwise auto-provision
try :
user_exists = any ( u [ "username" ] == normalized_username for u in self . registry . user_service . list_users ())
if not user_exists :
import secrets
# Provision new user with random password (never used directly)
self . registry . user_service . create_user ( normalized_username , secrets . token_hex ( 32 ))
except Exception as e :
context . abort ( grpc . StatusCode . INTERNAL , f "Failed to auto-provision user: { str ( e ) } " )
# Generate native connpy JWT token
token = self . registry . user_service . generate_jwt ( normalized_username )
expires_at = int (( datetime . datetime . now ( datetime . timezone . utc ) + datetime . timedelta ( hours = 12 )) . timestamp ())
return connpy_pb2 . LoginResponse (
token = token ,
username = normalized_username ,
expires_at = expires_at
)
@handle_errors
def get_sso_providers ( self , request , context ):
sso_config = {}
if self . registry :
shared_config = self . registry . get_shared_config ()
if shared_config :
sso_config = shared_config . config . get ( "sso" , {})
providers = list ( sso_config . get ( "providers" , {}) . keys ())
external_providers = [ p for p in providers if p != "trusted_gateway" ]
return connpy_pb2 . SSOProvidersResponse ( providers = external_providers )
2026-05-28 09:27:54 -03:00
@handle_errors
def change_password ( self , request , context ):
username = _current_user . get ()
if not username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Authentication required" )
try :
self . registry . user_service . change_password ( username , request . old_password , request . new_password )
self . registry . evict ( username )
except ValueError as e :
context . abort ( grpc . StatusCode . INVALID_ARGUMENT , str ( e ))
return Empty ()
2026-08-11 11:40:12 -03:00
@handle_errors
def create_api_token ( self , request , context ):
username = _current_user . get ()
if not username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Authentication required" )
try :
expires_in_days = request . expires_in_days if request . expires_in_days > 0 else None
result = self . registry . user_service . create_api_token (
username , request . name , expires_in_days = expires_in_days
)
except ValueError as e :
context . abort ( grpc . StatusCode . INVALID_ARGUMENT , str ( e ))
return connpy_pb2 . CreateApiTokenResponse (
token_id = result [ "token_id" ],
raw_token = result [ "raw_token" ],
name = result [ "name" ],
)
@handle_errors
def list_api_tokens ( self , request , context ):
username = _current_user . get ()
if not username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Authentication required" )
tokens = self . registry . user_service . list_api_tokens ( username )
token_infos = [
connpy_pb2 . ApiTokenInfo (
token_id = t [ "token_id" ],
name = t . get ( "name" ) or "" ,
token_prefix = t . get ( "token_prefix" ) or "" ,
created_at = t . get ( "created_at" ) or "" ,
last_used_at = t . get ( "last_used_at" ) or "" ,
expires_at = t . get ( "expires_at" ) or "" ,
)
for t in tokens
]
return connpy_pb2 . ListApiTokensResponse ( tokens = token_infos )
@handle_errors
def revoke_api_token ( self , request , context ):
username = _current_user . get ()
if not username :
context . abort ( grpc . StatusCode . UNAUTHENTICATED , "Authentication required" )
removed = self . registry . user_service . revoke_api_token ( username , request . token_id )
if not removed :
context . abort ( grpc . StatusCode . NOT_FOUND , f "Token ' { request . token_id } ' not found" )
return Empty ()
2026-05-28 09:27:54 -03:00
class AuthInterceptor ( grpc . ServerInterceptor ):
2026-06-04 18:33:26 -03:00
OPEN_METHODS = [ "/connpy.AuthService/login" , "/connpy.AuthService/login_sso" , "/connpy.AuthService/get_sso_providers" ]
2026-05-28 09:27:54 -03:00
def __init__ ( self , registry ):
self . registry = registry
def intercept_service ( self , continuation , handler_call_details ):
method = handler_call_details . method
if method in self . OPEN_METHODS :
return continuation ( handler_call_details )
if not self . registry . has_users ():
return continuation ( handler_call_details )
token = self . _extract_token ( handler_call_details . invocation_metadata )
if not token :
return self . _unauthenticated_handler ( handler_call_details , "Authorization token is missing" )
username = self . registry . user_service . verify_jwt ( token )
2026-08-11 11:40:12 -03:00
if not username and token . startswith ( "cnp_pat_" ):
username = self . registry . user_service . verify_api_token ( token )
2026-05-28 09:27:54 -03:00
if not username :
return self . _unauthenticated_handler ( handler_call_details , "Invalid or expired token" )
handler = continuation ( handler_call_details )
if handler is None :
return None
return self . _wrap_handler ( handler , username )
def _wrap_handler ( self , handler , username ):
if handler . unary_unary :
original_behavior = handler . unary_unary
def wrapper ( request , context ):
token = _current_user . set ( username )
try :
return original_behavior ( request , context )
finally :
_current_user . reset ( token )
return grpc . unary_unary_rpc_method_handler (
wrapper ,
request_deserializer = handler . request_deserializer ,
response_serializer = handler . response_serializer ,
)
elif handler . unary_stream :
original_behavior = handler . unary_stream
def wrapper ( request , context ):
token = _current_user . set ( username )
try :
for response in original_behavior ( request , context ):
yield response
finally :
_current_user . reset ( token )
return grpc . unary_stream_rpc_method_handler (
wrapper ,
request_deserializer = handler . request_deserializer ,
response_serializer = handler . response_serializer ,
)
elif handler . stream_unary :
original_behavior = handler . stream_unary
def wrapper ( request_iterator , context ):
token = _current_user . set ( username )
try :
return original_behavior ( request_iterator , context )
finally :
_current_user . reset ( token )
return grpc . stream_unary_rpc_method_handler (
wrapper ,
request_deserializer = handler . request_deserializer ,
response_serializer = handler . response_serializer ,
)
elif handler . stream_stream :
original_behavior = handler . stream_stream
def wrapper ( request_iterator , context ):
token = _current_user . set ( username )
try :
for response in original_behavior ( request_iterator , context ):
yield response
finally :
_current_user . reset ( token )
return grpc . stream_stream_rpc_method_handler (
wrapper ,
request_deserializer = handler . request_deserializer ,
response_serializer = handler . response_serializer ,
)
return handler
def _extract_token ( self , metadata ):
for key , value in metadata :
if key . lower () == "authorization" :
if value . startswith ( "Bearer " ):
return value [ 7 :]
return None
def _unauthenticated_handler ( self , handler_call_details , message ):
def abort_call ( request_or_iterator , context ):
context . abort ( grpc . StatusCode . UNAUTHENTICATED , message )
return grpc . unary_unary_rpc_method_handler ( abort_call )
2026-04-17 18:42:08 -03:00
class LoggingInterceptor ( grpc . ServerInterceptor ):
def __init__ ( self ):
from rich.console import Console
2026-04-24 19:23:00 -03:00
from ..printer import connpy_theme , get_original_stdout
self . console = Console ( theme = connpy_theme , file = get_original_stdout ())
2026-04-17 18:42:08 -03:00
def intercept_service ( self , continuation , handler_call_details ):
import time
method = handler_call_details . method
self . console . print ( f "[debug][DEBUG][/debug] gRPC Incoming Request: [bold cyan] { method } [/bold cyan]" )
start_time = time . time ()
try :
result = continuation ( handler_call_details )
except Exception as e :
self . console . print ( f "[debug][DEBUG][/debug] [bold red]ERROR[/bold red] in { method } : { e } " )
raise e
finally :
duration = ( time . time () - start_time ) * 1000
self . console . print ( f "[debug][DEBUG][/debug] Completed [bold cyan] { method } [/bold cyan] in { duration : .2f } ms" )
return result
def serve ( config , port = 8048 , debug = False ):
2026-05-28 09:27:54 -03:00
from connpy.grpc_layer.user_registry import UserRegistry
from connpy.services.provider import ServiceProvider
fallback_provider = ServiceProvider ( config , mode = "local" )
registry = UserRegistry ( config . defaultdir )
2026-06-04 18:33:26 -03:00
# Check if trusted_gateway provider is configured if SSO Gateway Secret is present in env
import os
if os . getenv ( "CONN_SSO_GATEWAY_SECRET" ) and registry . _shared_config :
sso_config = registry . _shared_config . config . get ( "sso" , {})
providers = sso_config . get ( "providers" , {})
if "trusted_gateway" not in providers :
from connpy import printer
printer . warning ( "CONN_SSO_GATEWAY_SECRET is defined in environment, but 'trusted_gateway' is not configured as an SSO provider in config.yaml. Forward Auth flow will not work." )
2026-05-28 09:27:54 -03:00
interceptors = []
if debug :
interceptors . append ( LoggingInterceptor ())
interceptors . append ( AuthInterceptor ( registry ))
2026-04-17 18:42:08 -03:00
server = grpc . server ( futures . ThreadPoolExecutor ( max_workers = 10 ), interceptors = interceptors )
2026-05-28 09:27:54 -03:00
connpy_pb2_grpc . add_NodeServiceServicer_to_server ( NodeServicer ( fallback_provider , registry = registry , debug = debug ), server )
connpy_pb2_grpc . add_ProfileServiceServicer_to_server ( ProfileServicer ( fallback_provider , registry = registry ), server )
connpy_pb2_grpc . add_ConfigServiceServicer_to_server ( ConfigServicer ( fallback_provider , registry = registry ), server )
plugin_servicer = PluginServicer ( fallback_provider , registry = registry )
2026-04-17 18:42:08 -03:00
connpy_pb2_grpc . add_PluginServiceServicer_to_server ( plugin_servicer , server )
remote_plugin_pb2_grpc . add_RemotePluginServiceServicer_to_server ( plugin_servicer , server )
2026-05-28 09:27:54 -03:00
connpy_pb2_grpc . add_ExecutionServiceServicer_to_server ( ExecutionServicer ( fallback_provider , registry = registry ), server )
connpy_pb2_grpc . add_ImportExportServiceServicer_to_server ( ImportExportServicer ( fallback_provider , registry = registry ), server )
2026-05-28 10:47:21 -03:00
connpy_pb2_grpc . add_AIServiceServicer_to_server ( AIServicer ( fallback_provider , registry = registry , debug = debug ), server )
2026-05-28 09:27:54 -03:00
connpy_pb2_grpc . add_SystemServiceServicer_to_server ( SystemServicer ( fallback_provider , registry = registry ), server )
connpy_pb2_grpc . add_AuthServiceServicer_to_server ( AuthServicer ( registry ), server )
2026-04-17 18:42:08 -03:00
server . add_insecure_port ( f '[::]: { port } ' )
server . start ()
return server