Files
connpy/connpy/grpc_layer/server.py
T

1773 lines
76 KiB
Python

import grpc
from concurrent import futures
from google.protobuf.empty_pb2 import Empty
import os
import ctypes
import threading
import contextvars
import datetime
# 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
from .. import printer
_current_user = contextvars.ContextVar("current_user", default=None)
def handle_errors(func):
import inspect
if inspect.isgeneratorfunction(func):
def wrapper(*args, **kwargs):
try:
for item in func(*args, **kwargs):
yield item
except grpc.RpcError:
raise
except ConnpyError as e:
context = kwargs.get("context") or args[-1]
context.abort(grpc.StatusCode.INTERNAL, str(e))
except Exception as e:
if type(e) is Exception and not e.args:
raise e
if e.__class__.__name__ in ("_AbortError", "RpcError"):
raise e
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)
except grpc.RpcError:
raise
except ConnpyError as e:
context = kwargs.get("context") or args[-1]
context.abort(grpc.StatusCode.INTERNAL, str(e))
except Exception as e:
if type(e) is Exception and not e.args:
raise e
if e.__class__.__name__ in ("_AbortError", "RpcError"):
raise e
context = kwargs.get("context") or args[-1]
context.abort(grpc.StatusCode.UNKNOWN, str(e))
finally:
printer.clear_thread_state()
return wrapper
class NodeServicer(connpy_pb2_grpc.NodeServiceServicer):
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
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())
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
@handle_errors
def interact_node(self, request_iterator, context):
import sys
import os
import asyncio
from connpy.core import node
from connpy.tunnels import RemoteStream
import queue
import threading
# 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
# 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
if self.server_debug:
self.server_console.print(f"[debug][DEBUG][/debug] gRPC interact_node request for: [bold cyan]{unique_id}[/bold cyan]")
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']
fallback_id = f"{unique_id}@remote"
if unique_id == "dynamic" and params.get("host"):
fallback_id = f"dynamic-{params.get('host')}@remote"
if base_node_id:
# Look up the base node in config and use its full data
nodes = user_config._getallnodes(base_node_id)
if nodes:
device = user_config.getitem(nodes[0])
# Override device properties with any passed in params
for attr in valid_attrs:
if attr in params:
device[attr] = params[attr]
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
node_name = params.get("name", base_node_id)
n = node(node_name, **device, config=user_config)
else:
# base_node not found, fall back to dynamic
node_name = params.get("name", fallback_id)
n = node(node_name, host=params.get("host", ""), config=user_config)
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)
n = node(node_name, host=params.get("host", ""), config=user_config)
for attr in valid_attrs:
if attr in params:
setattr(n, attr, params[attr])
if "tags" in params:
n.tags = params["tags"]
n._orig_protocol = n.protocol
if sftp:
n.protocol = "sftp"
else:
try:
node_data = user_config.getitem(unique_id, extract=False)
except (KeyError, TypeError):
node_data = None
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)
n = node(unique_id, **resolved_data, config=user_config)
if sftp:
n.protocol = "sftp"
# 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)
if connect != True:
yield connpy_pb2.InteractResponse(success=False, error_message=str(connect))
return
# Signal successful connection to the client
yield connpy_pb2.InteractResponse(success=True)
# 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
response_queue = queue.Queue()
remote_stream = RemoteStream(request_iterator, response_queue)
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
async def remote_copilot_handler(buffer, node_info, stream, child_fd, cmd_byte_positions=None):
import json
import asyncio
import os
service = ai_service
if node_info is None:
node_info = {}
# 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
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'))
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:
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
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))
node_info_json = json.dumps(node_info)
# 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:]
# 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)
# 1. Send prompt to client
response_queue.put(connpy_pb2.InteractResponse(
copilot_prompt=True,
copilot_buffer_preview=preview_str,
copilot_node_info_json=node_info_json
))
while True:
# 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
# 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
# 2. Await the question from client via the copilot_queue
import threading
def preload_ai_deps():
try:
import litellm
except Exception:
pass
threading.Thread(target=preload_ai_deps, daemon=True).start()
try:
req_data = await asyncio.wait_for(remote_stream.copilot_queue.get(), timeout=120)
if not req_data: return
# 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
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
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')
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:
os.write(child_fd, b'\x15\r')
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()
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')
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")
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
if action == "continue":
continue # Loop back for next question
if action in ("cancel", "web_cancel"):
if action == "web_cancel":
os.write(child_fd, b'\x05')
else:
os.write(child_fd, b'\x15\r')
return
except asyncio.TimeoutError:
os.write(child_fd, b'\x15\r')
return
def on_inject(cmd):
response_queue.put(connpy_pb2.InteractResponse(copilot_injected_command=cmd))
if action == "send_all":
commands = result.get("commands", [])
await n.inject_commands(commands, child_fd, on_inject=on_inject)
elif action.startswith("custom:"):
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)
else:
os.write(child_fd, b'\x15\r')
return
# 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
asyncio.run(n._async_interact_loop(remote_stream, resize_callback, copilot_handler=remote_copilot_handler))
except Exception as e:
import traceback
print(f"[ERROR in run_async_loop] {e}")
traceback.print_exc()
finally:
n._teardown_interact_environment()
response_queue.put(None) # Signal EOF
t_loop = threading.Thread(target=run_async_loop, daemon=True)
t_loop.start()
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()
@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)))
@handle_errors
def validate_parent_folder(self, request, context):
self.service.validate_parent_folder(request.id)
return Empty()
@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):
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().profiles
@property
def node_service(self):
return self._get_provider().nodes
@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):
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
@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):
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
@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):
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
@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)
# 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
q = queue.Queue()
def _on_complete(unique, output, status):
q.put({"unique_id": unique, "output": output, "status": status})
def _worker():
try:
execution_service.run_commands( nodes_filter=nodes_filter,
commands=list(request.commands),
folder=request.folder if request.folder else None,
prompt=request.prompt if request.prompt else None,
parallel=request.parallel,
timeout=request.timeout if request.timeout > 0 else 10,
variables=from_struct(request.vars) if request.HasField("vars") else None,
on_node_complete=_on_complete,
name=request.name if request.name else None
)
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)
import contextvars
ctx = contextvars.copy_context()
threading.Thread(target=lambda: ctx.run(_worker), daemon=True).start()
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)
# Resolve provider in the main gRPC thread where _current_user ContextVar is set.
execution_service = self.service
q = queue.Queue()
def _on_complete(unique, node_output, node_status, node_result):
q.put({"unique_id": unique, "output": node_output, "status": node_status, "result": node_result})
def _worker():
try:
execution_service.test_commands(
nodes_filter=nodes_filter,
commands=list(request.commands),
expected=list(request.expected),
folder=request.folder if request.folder else None,
prompt=request.prompt if request.prompt else None,
parallel=request.parallel,
timeout=request.timeout if request.timeout > 0 else 10,
variables=from_struct(request.vars) if request.HasField("vars") else None,
on_node_complete=_on_complete,
name=request.name if request.name else None
)
except Exception as e:
q.put(e)
finally:
q.put(None)
import contextvars
ctx = contextvars.copy_context()
threading.Thread(target=lambda: ctx.run(_worker), daemon=True).start()
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):
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
@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:
def __init__(self, q, request_queue=None, is_web=False):
self.q = q
self.request_queue = request_queue
self.on_interrupt = self._force_interrupt
self.thread = None
self.is_web = is_web
self.is_remote = True
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
import ctypes
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
from rich.panel import Panel
from io import StringIO
from ..printer import connpy_theme
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)
buf = StringIO()
# 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))
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):
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
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())
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
def _handle_chat_stream(self, request_iterator, context, service_method):
import queue
import threading
import contextvars
chunk_queue = queue.Queue()
request_queue = queue.Queue()
bridge = None
history = []
is_web = False
# Dedicated event to signal AI thread to stop
ai_thread = None
agent_instance = None
def callback(chunk):
chunk_queue.put(("text", chunk))
def run_ai_task(input_text, session_id, debug, overrides, trust):
nonlocal history, bridge, agent_instance
try:
# Run the AI interaction (this blocks this specific thread)
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,
console=bridge,
confirm_handler=bridge.confirm,
chunk_callback=callback,
trust=trust,
**overrides
)
# Update history for next message
if res and "chat_history" in res:
history = res["chat_history"]
# Send final chunk marker
chunk_queue.put(("final_mark", res))
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}))
except Exception as e:
import traceback
print(f"AI Task Error: {e}")
traceback.print_exc()
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}))
def request_listener():
nonlocal bridge, is_web, ai_thread, agent_instance, history
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-")
# 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 []
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
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)
# Start AI in its own thread with a fresh copy of context so we can keep listening for interrupts
ctx_ai = contextvars.copy_context()
ai_thread = threading.Thread(
target=lambda: ctx_ai.run(run_ai_task, req.input_text, req.session_id, req.debug, overrides, req.trust),
daemon=True
)
ai_thread.start()
except grpc.RpcError:
pass
except Exception as e:
print(f"Request Listener Error: {e}")
finally:
# When client closes stream, send sentinel
chunk_queue.put((None, None))
# 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()
# Main response loop (yields to gRPC)
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":
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)
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))
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))
import contextvars
ctx = contextvars.copy_context()
threading.Thread(target=lambda: ctx.run(_worker), daemon=True).start()
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)
@handle_errors
def confirm(self, request, context):
res = self.service.confirm(request.value)
return connpy_pb2.BoolResponse(value=res)
@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 ""
)
@handle_errors
def list_sessions(self, request, context):
sessions, total = self.service.list_sessions()
return connpy_pb2.ValueResponse(data=to_value(sessions))
@handle_errors
def delete_session(self, request, context):
self.service.delete_session(request.value)
return Empty()
@handle_errors
def configure_provider(self, request, context):
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)
return Empty()
@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()
@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))
@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):
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
@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())
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)
expires_at = int((datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=12)).timestamp())
return connpy_pb2.LoginResponse(
token=token,
username=username,
expires_at=expires_at
)
@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)
@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()
@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()
class AuthInterceptor(grpc.ServerInterceptor):
OPEN_METHODS = ["/connpy.AuthService/login", "/connpy.AuthService/login_sso", "/connpy.AuthService/get_sso_providers"]
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)
if not username and token.startswith("cnp_pat_"):
username = self.registry.user_service.verify_api_token(token)
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)
class LoggingInterceptor(grpc.ServerInterceptor):
def __init__(self):
from rich.console import Console
from ..printer import connpy_theme, get_original_stdout
self.console = Console(theme=connpy_theme, file=get_original_stdout())
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):
from connpy.grpc_layer.user_registry import UserRegistry
from connpy.services.provider import ServiceProvider
fallback_provider = ServiceProvider(config, mode="local")
registry = UserRegistry(config.defaultdir)
# 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.")
interceptors = []
if debug:
interceptors.append(LoggingInterceptor())
interceptors.append(AuthInterceptor(registry))
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=interceptors)
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)
connpy_pb2_grpc.add_PluginServiceServicer_to_server(plugin_servicer, server)
remote_plugin_pb2_grpc.add_RemotePluginServiceServicer_to_server(plugin_servicer, server)
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)
connpy_pb2_grpc.add_AIServiceServicer_to_server(AIServicer(fallback_provider, registry=registry, debug=debug), server)
connpy_pb2_grpc.add_SystemServiceServicer_to_server(SystemServicer(fallback_provider, registry=registry), server)
connpy_pb2_grpc.add_AuthServiceServicer_to_server(AuthServicer(registry), server)
server.add_insecure_port(f'[::]:{port}')
server.start()
return server