codespeak-cli 0.2.0__py3-none-any.whl

console_client/auth/token_storage.py

@@ -0,0 +1,122 @@
+"""Token storage module for managing user authentication tokens."""
+
+import json
+import os
+import time
+from pathlib import Path
+
+from pydantic import BaseModel
+
+# Buffer time in seconds before actual expiry to trigger re-login
+_TOKEN_EXPIRY_BUFFER_SECONDS = 30
+
+
+class StoredToken(BaseModel):
+    """Token data stored in the token file."""
+
+    access_token: str
+    expires_at: int | None = None
+
+
+def get_codespeak_home() -> Path:
+    """Get the CodeSpeak home directory path (~/.codespeak)."""
+    return Path.home() / ".codespeak"
+
+
+def ensure_codespeak_home() -> Path:
+    """
+    Ensure the CodeSpeak home directory exists.
+
+    Creates the directory with secure permissions (0700) if it doesn't exist.
+
+    Returns:
+        Path to the CodeSpeak home directory.
+    """
+    codespeak_home = get_codespeak_home()
+    if not codespeak_home.exists():
+        codespeak_home.mkdir(parents=True, mode=0o700, exist_ok=True)
+    return codespeak_home
+
+
+def get_token_path() -> Path:
+    """Get the path to the token file (~/.codespeak/token.json)."""
+    return get_codespeak_home() / "token.json"
+
+
+def save_token(token: str, expires_in: int = 0) -> None:
+    """
+    Save the authentication token and its expiration time.
+
+    Creates the CodeSpeak home directory if it doesn't exist.
+    Sets file permissions to 0600 (owner read/write only) for security.
+
+    Args:
+        token: The authentication token to save.
+        expires_in: Token lifetime in seconds from now. If 0, no expiry is saved.
+
+    Raises:
+        OSError: If the token cannot be saved due to filesystem errors.
+    """
+    ensure_codespeak_home()
+    token_path = get_token_path()
+
+    expires_at = int(time.time()) + expires_in if expires_in > 0 else None
+    stored = StoredToken(access_token=token, expires_at=expires_at)
+
+    token_path.write_text(stored.model_dump_json(), encoding="utf-8")
+    os.chmod(token_path, 0o600)
+
+
+def _load_stored_token() -> StoredToken | None:
+    """Load the stored token data from the token file."""
+    token_path = get_token_path()
+    if not token_path.exists():
+        return None
+
+    try:
+        data = json.loads(token_path.read_text(encoding="utf-8"))
+        return StoredToken.model_validate(data)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+def load_user_token() -> str | None:
+    """
+    Load the authentication token from the token file.
+
+    Returns:
+        The authentication token if it exists, None otherwise.
+    """
+    stored = _load_stored_token()
+    return stored.access_token if stored else None
+
+
+def delete_token() -> None:
+    """
+    Delete the authentication token file.
+
+    Does nothing if the file doesn't exist.
+
+    Raises:
+        OSError: If the file exists but cannot be deleted.
+    """
+    token_path = get_token_path()
+    if token_path.exists():
+        token_path.unlink()
+
+
+def is_token_expired() -> bool:
+    """
+    Check if the stored token is expired or about to expire.
+
+    Returns True if the token is expired or will expire within the buffer period,
+    giving time for re-login before actual expiry.
+
+    Returns:
+        True if token is expired or will expire soon, False otherwise.
+    """
+    stored = _load_stored_token()
+    if not stored or stored.expires_at is None:
+        return False
+
+    return time.time() >= stored.expires_at - _TOKEN_EXPIRY_BUFFER_SECONDS

console_client/build_client.py

@@ -0,0 +1,318 @@
+"""
+Build client for connecting to remote CodeSpeak build server.
+"""
+
+import json
+import logging
+import queue
+import threading
+from argparse import Namespace
+from collections.abc import Iterator
+from typing import Any, cast
+
+import grpc
+from api_stubs import os_environment_pb2
+from api_stubs.build_server_pb2 import (
+    CancelBuildRequest,
+    ClientMessage,
+    ServerMessage,
+    StartBuildRequest,
+)
+from api_stubs.build_server_pb2_grpc import BuildServiceStub
+from api_stubs.operation_logging import OsEnvRequestLogging
+from api_stubs.os_environment_pb2 import OperationRequest, OperationResponse
+from codespeak_shared import BuildResult
+from codespeak_shared.build_insight.events import (
+    BuildInsightEvent,
+    ProgressItemCreateEvent,
+    ProgressItemUpdateEvent,
+    SpanCloseEvent,
+    SpanOpenEvent,
+    TestsRunEvent,
+    TextOutputEvent,
+    ToolCallEvent,
+    UserVisibleModelOutputEvent,
+)
+from codespeak_shared.build_insight.storage import BuildInsightStorage, BuildInsightStorageMode
+from codespeak_shared.codespeak_project import FileBasedCodeSpeakProject
+from codespeak_shared.env_allowlist import filter_env_vars
+from codespeak_shared.exceptions import (
+    BuildStartFailedUserError,
+    CodespeakInternalError,
+    CodeSpeakServerUnavailableUserError,
+)
+from codespeak_shared.os_environment import OsEnvironment
+from codespeak_shared.progress.rich_progress_output import RichBasedCliProgressRenderer
+from codespeak_shared.protocol_version import CURRENT_VERSION as PROTOCOL_VERSION
+from rich.console import Console
+
+from console_client.auth.token_storage import load_user_token
+from console_client.build_client_event_converter import (
+    convert_build_finished_proto_to_result,
+    convert_proto_to_build_insight_event,
+)
+from console_client.client_feature_flags import ConsoleClientFeatureFlags
+from console_client.os_environment_servicer import OsEnvironmentServicer
+from console_client.sequence_reorder_buffer import SequenceReorderBuffer
+
+
+def _get_build_insight_event_summary(event: BuildInsightEvent) -> str:
+    if isinstance(event, ProgressItemCreateEvent):
+        return f"create '{event.title}' [{event.status.value}]"
+    elif isinstance(event, ProgressItemUpdateEvent):
+        status_text = f" ({event.status_text})" if event.status_text else ""
+        return f"update [{event.status.value}]{status_text}"
+    elif isinstance(event, ToolCallEvent):
+        return f"tool '{event.title}'"
+    elif isinstance(event, TextOutputEvent):
+        text_preview = event.text[:50] + "..." if len(event.text) > 50 else event.text
+        return f"text: {text_preview}"
+    elif isinstance(event, UserVisibleModelOutputEvent):
+        text_preview = event.text[:50] + "..." if len(event.text) > 50 else event.text
+        return f"output: {text_preview}"
+    elif isinstance(event, SpanOpenEvent):
+        return f"span_open '{event.title}'"
+    elif isinstance(event, SpanCloseEvent):
+        return f"span_close '{event.span_id[:8]}'"
+    elif isinstance(event, TestsRunEvent):
+        return "tests_run"
+    else:
+        return type(event).__name__
+
+
+def _handle_os_env_request(
+    request: OperationRequest,
+    os_env: OsEnvironment,
+    logger: logging.Logger,
+    console: Console,
+) -> OperationResponse:
+    """Handle an OsEnvironment operation request from the server."""
+    try:
+        # Use OsEnvironmentServicer to handle the request
+        servicer = OsEnvironmentServicer(os_env, console)
+
+        # Handle the request synchronously
+        # The servicer's StreamOperations method processes requests one at a time
+        def request_iter() -> Iterator[OperationRequest]:
+            yield request
+
+        # Process the request and get the response
+        response_iterator = servicer.StreamOperations(request_iter(), None)
+        response: OperationResponse = next(response_iterator)
+        return response
+    except Exception as e:  # noqa: BLE001 (os env handler catch-all block)
+        # Return a response with client_error set - server will check this field first
+        logger.exception(f"Error handling OsEnv request: {e}")
+        error_info = os_environment_pb2.ErrorInfo(
+            message=f"Client internal error: {type(e).__name__}: {e}",
+            type=os_environment_pb2.ErrorType.ERROR_TYPE_UNSPECIFIED,
+        )
+        return OperationResponse(request_id=request.request_id, client_internal_error=error_info)
+
+
+def run_build_client(
+    args: Namespace,
+    local_project: FileBasedCodeSpeakProject,
+    client_feature_flags: ConsoleClientFeatureFlags,
+    console: Console,
+    env: dict[str, str],
+) -> BuildResult:
+    server_host = client_feature_flags.get_flag_value(ConsoleClientFeatureFlags.CONSOLE_CLIENT_BUILD_SERVER_HOST)
+    server_port = client_feature_flags.get_flag_value(ConsoleClientFeatureFlags.CONSOLE_CLIENT_BUILD_SERVER_PORT)
+    use_secure = client_feature_flags.get_flag_value(ConsoleClientFeatureFlags.CONSOLE_CLIENT_BUILD_SERVER_SECURE)
+
+    server_address = f"{server_host}:{server_port}"
+    console.print(f"Connecting to {server_address}...", highlight=False)
+
+    # Load authentication token (or send empty token if feature flag is disabled)
+    if client_feature_flags.get_flag_value(ConsoleClientFeatureFlags.CONSOLE_CLIENT_SEND_USER_TOKEN):
+        user_token = load_user_token() or ""
+    else:
+        user_token = ""
+
+    print_grpc_events = client_feature_flags.get_flag_value(ConsoleClientFeatureFlags.CONSOLE_CLIENT_PRINT_GRPC_EVENTS)
+
+    def print_grpc_event(message: str) -> None:
+        console.print(f"[Client] {message}", style="dim")
+
+    follower_build_insight_storage = BuildInsightStorage(mode=BuildInsightStorageMode.FOLLOWER)
+    cli_renderer = RichBasedCliProgressRenderer(
+        console, follower_build_insight_storage, interactive=(not args.no_interactive)
+    )
+
+    # Create reorder buffer to handle out-of-order events
+    def publish_to_storage(event: BuildInsightEvent) -> None:
+        # Events come from the server with sequence numbers already assigned
+        follower_build_insight_storage.report_event(event)
+
+    build_insight_events_buffer = SequenceReorderBuffer[BuildInsightEvent](publish_to_storage)
+
+    # Connect to server using secure or insecure channel
+    if use_secure:
+        ssl_credentials = grpc.ssl_channel_credentials()
+        channel = grpc.secure_channel(server_address, ssl_credentials)
+    else:
+        channel = grpc.insecure_channel(server_address)
+
+    stub = cast(Any, BuildServiceStub(channel))
+
+    # Create request queue for bidirectional streaming
+    # Use None as sentinel to signal end of requests
+    request_queue: queue.Queue[ClientMessage | None] = queue.Queue()
+
+    # Create request iterator
+    def request_iterator() -> Iterator[ClientMessage]:
+        while True:
+            message = request_queue.get()
+            if message is None:
+                # Sentinel value - stop sending requests
+                break
+            yield message
+
+    # Start bidirectional stream
+    response_stream = stub.Build(request_iterator())
+
+    # Serialize args to JSON (convert Namespace to dict)
+    args_dict = vars(args)
+    args_json = json.dumps(args_dict)
+
+    # Send StartBuild message with settings, args, feature flags, and user token
+    # Convert feature flags to map<string, string> (protobuf requirement)
+    feature_flags_str = {k: str(v) for k, v in client_feature_flags.to_dict().items()}
+    start_request = ClientMessage(
+        start_build=StartBuildRequest(
+            project_root=str(local_project.project_root.get_underlying_path().resolve()),
+            settings_json=local_project.settings_json_str(),
+            args_json=args_json,
+            client_feature_flags=feature_flags_str,
+            env_vars=filter_env_vars(env),
+            user_token=user_token,
+            client_protocol_version=PROTOCOL_VERSION,
+        )
+    )
+    if print_grpc_events:
+        print_grpc_event("Sending: start_build")
+
+    request_queue.put(start_request)
+
+    result: BuildResult | None = None
+    stop_event = threading.Event()
+    cancellation_requested = threading.Event()
+
+    logger = logging.getLogger(__name__)
+
+    # Process server messages in a separate thread to handle os_env_request
+    def process_server_messages() -> None:
+        nonlocal result
+        try:
+            for server_message in response_stream:
+                if stop_event.is_set():
+                    break
+
+                server_message = cast(ServerMessage, server_message)
+                which = server_message.WhichOneof("message")
+
+                if print_grpc_events and which not in ("os_env_request", "build_insight_event"):
+                    # Don't print generic "Received" for these since we print detailed "Handling" messages
+                    print_grpc_event(f"Received: {which}")
+
+                if which == "build_started":
+                    build_started = server_message.build_started
+                    result_type = build_started.WhichOneof("result")
+                    if result_type == "failure":
+                        error = BuildStartFailedUserError(build_started.failure.message)
+                        result = BuildResult.failed("build", error)
+                        break
+                    message = f"Remote build started (ID: {build_started.success.build_id})"
+                    logger.info(message)
+                    console.print(message, highlight=False)
+
+                elif which == "build_insight_event":
+                    # Convert protobuf event back to Python and add to reorder buffer
+                    # The buffer will handle out-of-order delivery and publish to storage in order
+                    proto_event = server_message.build_insight_event
+                    py_event = convert_proto_to_build_insight_event(proto_event)
+                    if print_grpc_events:
+                        summary = _get_build_insight_event_summary(py_event)
+                        print_grpc_event(f"Handling build_insight_event: {summary}")
+                    build_insight_events_buffer.add(py_event)
+
+                elif which == "os_env_request":
+                    # Handle file operation request from server
+                    os_request = cast(os_environment_pb2.OperationRequest, getattr(server_message, "os_env_request"))
+                    if print_grpc_events:
+                        request_description = OsEnvRequestLogging.format(os_request)
+                        print_grpc_event(f"Handling OsEnv request: {request_description}")
+                    os_response = _handle_os_env_request(os_request, local_project.os_env(), logger, console)
+                    # Send response back to server (don't log responses)
+                    client_msg = ClientMessage(os_env_response=os_response)
+                    request_queue.put(client_msg)
+
+                elif which == "build_finished":
+                    build_finished = server_message.build_finished
+                    logger.info(f"Received build finished message: {build_finished}")
+                    result = convert_build_finished_proto_to_result(build_finished)
+                    break
+
+        except grpc.RpcError as e:
+            logger.exception(f"Grpc error: {e}")
+
+            if not stop_event.is_set():
+                # Check if this is a connection error
+                if e.code() == grpc.StatusCode.UNAVAILABLE:
+                    # Convert to user-friendly error
+                    user_error = CodeSpeakServerUnavailableUserError(server_address)
+                    result = BuildResult.failed("build", user_error)
+                else:
+                    # Other gRPC errors
+                    console.print(f"Error during build: {e}", style="bright_red")
+                    result = BuildResult.failed("build", e)
+        except Exception as e:  # noqa: BLE001
+            if not stop_event.is_set():
+                logger.exception(f"Error during build ({type(e).__name__}): {e}")
+                console.print(f"Error during build: {e}", style="bright_red")
+                result = BuildResult.failed("build", e)
+
+    # Start processing server messages in a thread
+    message_thread = threading.Thread(target=process_server_messages, daemon=False)
+    message_thread.start()
+
+    try:
+        while True:
+            try:
+                # Wait for the thread to complete
+                message_thread.join(timeout=0.1)
+                if not message_thread.is_alive():
+                    break
+            except KeyboardInterrupt:
+                # Do not interrupt client loop immediately.
+                # Instead, send build cancellation request to the server and so let it finish the loop
+                if not cancellation_requested.is_set():
+                    cli_renderer.append_text("[yellow]Waiting for server to cancel build...[/yellow]")
+                    cli_renderer.append_text("[yellow]Press Ctrl+C again to force exit[/yellow]")
+                    cancellation_requested.set()
+                    # Send CancelBuild request to server
+                    cancel_request = ClientMessage(cancel_build=CancelBuildRequest())
+                    if print_grpc_events:
+                        print_grpc_event("Sending: cancel_build")
+                    request_queue.put(cancel_request)
+                else:
+                    # Second Ctrl+C - force exit without waiting for server
+                    cli_renderer.append_text("[yellow]Force exiting...[/yellow]")
+                    break
+    finally:
+        stop_event.set()
+        # Send sentinel to stop the request iterator cleanly
+        request_queue.put(None)
+        cli_renderer.finalize()
+        channel.close()
+
+    if result is None:
+        if cancellation_requested.is_set():
+            result = BuildResult.failed("build", KeyboardInterrupt())
+        else:
+            result = BuildResult.failed(
+                "build", CodespeakInternalError("Error: connection with server closed before obtaining build result")
+            )
+
+    return result

console_client/build_client_event_converter.py

@@ -0,0 +1,156 @@
+"""Converter from protobuf BuildInsightEvent messages to Python objects."""
+
+from typing import Any
+
+from api_stubs import build_server_pb2
+from api_stubs.build_server_pb2 import BuildFinished, BuildResultType
+from codespeak_shared import BuildResult
+from codespeak_shared.build_insight.events import (
+    BuildInsightEvent,
+    ProgressItemCreateEvent,
+    ProgressItemStatus,
+    ProgressItemUpdateEvent,
+    SpanCloseEvent,
+    SpanOpenEvent,
+    StopInteractiveProgressEvent,
+    TestsRunEvent,
+    TextOutputEvent,
+    ToolCallEvent,
+    UserVisibleModelOutputEvent,
+)
+from codespeak_shared.exceptions import CodespeakInternalError, CodespeakUserError
+from codespeak_shared.test_runner_types import TestResults
+
+
+def _convert_progress_status_from_proto(status: int) -> ProgressItemStatus:
+    """Convert protobuf enum to Python ProgressItemStatus."""
+    mapping: dict[int, ProgressItemStatus] = {
+        int(build_server_pb2.PROGRESS_ITEM_STATUS_PENDING): ProgressItemStatus.PENDING,
+        int(build_server_pb2.PROGRESS_ITEM_STATUS_IN_PROGRESS): ProgressItemStatus.IN_PROGRESS,
+        int(build_server_pb2.PROGRESS_ITEM_STATUS_SKIPPED): ProgressItemStatus.SKIPPED,
+        int(build_server_pb2.PROGRESS_ITEM_STATUS_DONE): ProgressItemStatus.DONE,
+        int(build_server_pb2.PROGRESS_ITEM_STATUS_FAILED): ProgressItemStatus.FAILED,
+    }
+    result = mapping.get(status)
+    return result if result is not None else ProgressItemStatus.PENDING
+
+
+def convert_proto_to_build_insight_event(proto_event: Any) -> BuildInsightEvent:
+    """Convert a protobuf BuildInsightEvent to a Python BuildInsightEvent."""
+    which = proto_event.WhichOneof("event")
+
+    sequence_number = proto_event.sequence_number
+
+    if which == "progress_item_create":
+        create = proto_event.progress_item_create
+        return ProgressItemCreateEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            progress_item_id=create.progress_item_id,
+            status=_convert_progress_status_from_proto(create.status),
+            title=create.title,
+            description=create.description if create.description else None,
+            parent_item_id=create.parent_item_id if create.parent_item_id else None,
+            status_text=create.status_text if create.status_text else None,
+        )
+    elif which == "progress_item_update":
+        update = proto_event.progress_item_update
+        return ProgressItemUpdateEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            progress_item_id=update.progress_item_id,
+            status=_convert_progress_status_from_proto(update.status),
+            status_text=update.status_text if update.status_text else None,
+        )
+    elif which == "text_output":
+        text = proto_event.text_output
+        return TextOutputEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            text=text.text,
+            parent_progress_item_id=text.parent_progress_item_id if text.parent_progress_item_id else None,
+        )
+    elif which == "tool_call":
+        tool = proto_event.tool_call
+        return ToolCallEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            title=tool.title,
+            details=tool.details if tool.details else None,
+            parent_progress_item_id=tool.parent_progress_item_id if tool.parent_progress_item_id else None,
+        )
+    elif which == "user_visible_model_output":
+        model_out = proto_event.user_visible_model_output
+        return UserVisibleModelOutputEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            text=model_out.text,
+            parent_progress_item_id=model_out.parent_progress_item_id if model_out.parent_progress_item_id else None,
+        )
+    elif which == "span_open":
+        span = proto_event.span_open
+        return SpanOpenEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            span_id=span.span_id,
+            title=span.title,
+            description=span.description if span.description else None,
+        )
+    elif which == "span_close":
+        span = proto_event.span_close
+        return SpanCloseEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            span_id=span.span_id,
+        )
+    elif which == "tests_run":
+        tests = proto_event.tests_run
+        test_results = None
+        if tests.test_results_json:
+            test_results = TestResults.model_validate_json(tests.test_results_json)
+        return TestsRunEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+            test_results=test_results,
+        )
+    elif which == "stop_interactive_progress":
+        return StopInteractiveProgressEvent(
+            timestamp=proto_event.timestamp,
+            sequence_number=sequence_number,
+        )
+    else:
+        raise ValueError(f"Unknown type {which} of event {proto_event}")
+
+
+def convert_build_finished_proto_to_result(build_finished: BuildFinished) -> BuildResult:
+    if build_finished.result_type == BuildResultType.BUILD_RESULT_SUCCEEDED:
+        result = BuildResult.succeeded(build_finished.command)
+    elif build_finished.result_type == BuildResultType.BUILD_RESULT_SKIPPED:
+        result = BuildResult(BuildResult.SKIPPED, build_finished.command)
+    elif build_finished.result_type == BuildResultType.BUILD_RESULT_CANCELLED:
+        result = BuildResult.failed(build_finished.command, KeyboardInterrupt())
+    elif build_finished.result_type == BuildResultType.BUILD_RESULT_FAILED:
+        if not build_finished.build_error:
+            raise ValueError(f"build_finished.build_error is missing in {build_finished}")
+
+        build_error = build_finished.build_error
+
+        if build_error.HasField("user_error"):
+            exception = CodespeakUserError(user_visible_message=build_error.user_error.user_visible_message)
+        elif build_error.HasField("internal_error"):
+            exception = CodespeakInternalError(internal_message=build_error.internal_error.internal_message)
+        else:
+            raise ValueError(f"BuildError has neither user_error nor internal_error: {build_error}")
+
+        result = BuildResult.failed(build_finished.command, exception)
+    else:
+        raise ValueError(f"Unexpected build result type: {build_finished.result_type}")
+
+    # Set build statistics
+    if build_finished.build_stats:
+        stats = build_finished.build_stats
+        result.build_stats.cache_enabled = stats.cache_enabled
+        result.build_stats.cache_hits = stats.cache_hits
+        result.build_stats.cache_misses = stats.cache_misses
+
+    return result

console_client/client_feature_flags.py

@@ -0,0 +1,23 @@
+"""Console client feature flags."""
+
+from codespeak_shared.shared_feature_flags import FeatureFlag, FeatureFlagsMeta, SharedFeatureFlags
+
+
+class ConsoleClientFeatureFlags(SharedFeatureFlags, metaclass=FeatureFlagsMeta):
+    CONSOLE_CLIENT_PRINT_GRPC_EVENTS = FeatureFlag(default_value=False)
+
+    CONSOLE_CLIENT_SEND_USER_TOKEN = FeatureFlag(default_value=True)
+
+    CONSOLE_CLIENT_BUILD_SERVER_HOST = FeatureFlag(default_value="build.codespeak.dev")
+
+    CONSOLE_CLIENT_BUILD_SERVER_PORT = FeatureFlag(default_value=50053)
+
+    CONSOLE_CLIENT_BUILD_SERVER_SECURE = FeatureFlag(default_value=True)
+
+    CONSOLE_CLIENT_AUTH0_DOMAIN = FeatureFlag[str](default_value="codespeak.us.auth0.com")
+
+    CONSOLE_CLIENT_AUTH0_CLIENT_ID = FeatureFlag[str](default_value="zVHCedn5lS2hl6hiVtQuTMm9Hg2ZHZk9")
+
+    CONSOLE_CLIENT_AUTH0_SCOPES = FeatureFlag[str](default_value="openid profile email")
+
+    CONSOLE_CLIENT_AUTH0_CALLBACK_TIMEOUT = FeatureFlag[int](default_value=300)