Struct MountainVinegRPCService 

pub struct MountainVinegRPCService {
    ApplicationHandle: AppHandle,
    RunTime: Arc<ApplicationRunTime>,
    ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>,
}

The concrete implementation of the MountainService gRPC service.

This service handles all incoming RPC calls from the Cocoon sidecar, validating requests, dispatching to appropriate handlers, and returning responses in the expected gRPC format.

Fields

ApplicationHandle: AppHandle

Tauri application handle for VS Code integration

RunTime: Arc<ApplicationRunTime>

Application runtime containing core dependencies

ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>

Registry of active operations with their cancellation tokens Maps request ID to cancellation token for operation cancellation

Implementations

impl MountainVinegRPCService

pub fn ApplicationHandle(&self) -> &AppHandle

Accessor for Tauri AppHandle - used by the per-wire-method atoms in Vine::Server::Notification::* that need to emit sky:// / cocoon:* events downstream. Kept as a thin read so the struct’s fields can stay private; atoms should never mutate the handle, only emit through it.

pub fn RunTime(&self) -> &Arc<ApplicationRunTime>

Accessor for the shared ApplicationRunTime. Notification atoms reach Environment.ApplicationState.* (provider registry, extension registry, scheduler) through this. Clone from Arc when the atom needs to keep it across an .await boundary.

impl MountainVinegRPCService

pub fn Create( ApplicationHandle: AppHandle, RunTime: Arc<ApplicationRunTime>, ) -> Self

Creates a new instance of the Mountain gRPC service.

Parameters

• ApplicationHandle: Tauri app handle for framework integration
• RunTime: Application runtime with core dependencies

Returns

New MountainVinegRPCService instance

pub async fn RegisterOperation(&self, request_id: u64) -> CancellationToken

Registers an operation for potential cancellation

Parameters

• request_id: The request identifier for the operation

Returns

A cancellation token that can be used to cancel the operation

pub async fn UnregisterOperation(&self, request_id: u64)

Unregisters an operation after completion

Parameters

• request_id: The request identifier to unregister

fn ValidateRequest(&self, request: &GenericRequest) -> Result<(), Status>

Validates a generic request before processing.

Parameters

• request: The request to validate

Returns

• Ok(()): Request is valid
• Err(Status): Validation failed with appropriate gRPC status

fn CreateErrorResponse( RequestIdentifier: u64, code: i32, message: String, data: Option<Vec<u8>>, ) -> GenericResponse

Creates a JSON-RPC compliant error response.

Parameters

• RequestIdentifier: The request ID to echo back
• code: JSON-RPC error code
• message: Error message
• data: Optional error data (serialized)

Returns

GenericResponse with error populated

fn CreateSuccessResponse( RequestIdentifier: u64, result: &Value, ) -> GenericResponse

Creates a successful JSON-RPC response.

Parameters

• RequestIdentifier: The request ID to echo back
• result: Result value to serialize

Returns

GenericResponse with result populated, or error if serialization fails

Trait Implementations

impl MountainService for MountainVinegRPCService

fn process_cocoon_request<'life0, 'async_trait>( &'life0 self, request: Request<GenericRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GenericResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles generic request-response RPCs from Cocoon.

This is the main entry point for Cocoon to request operations from Mountain. It validates the request, deserializes parameters, dispatches to the Track module, and returns the result or error in JSON-RPC format.

Parameters

• request: GenericRequest containing method name and serialized parameters

Returns

• Ok(Response<GenericResponse>): Response with result or error
• Err(Status): gRPC status error (only for critical failures)

fn send_cocoon_notification<'life0, 'async_trait>( &'life0 self, request: Request<GenericNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles generic fire-and-forget notifications from Cocoon.

Notifications do not expect a response beyond acknowledgment. They are used for status updates, events, and other asynchronous notifications.

Parameters

• request: GenericNotification with method name and parameters

Returns

• Ok(Response<Empty>): Notification was received and logged
• Err(Status): Critical error during processing

TODO

Future implementation should route notifications to dedicated handlers:

let Parameter: Value = serde_json::from_slice(&notification.parameter)?;
NotificationHandler::Handle(MethodName, Parameter).await?;

fn cancel_operation<'life0, 'async_trait>( &'life0 self, request: Request<CancelOperationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles a request from Cocoon to cancel a long-running operation.

This method is called when Cocoon wants to cancel an operation that was previously initiated via process_cocoon_request.

Parameters

• request: CancelOperationRequest with the request ID to cancel

Returns

• Ok(Response<Empty>): Cancellation was initiated
• Err(Status): Critical error during cancellation

type OpenChannelFromCocoonStream = Pin<Box<dyn Stream<Item = Result<Envelope, Status>> + Send>>

Server streaming response type for the OpenChannelFromCocoon method.

fn open_channel_from_cocoon<'life0, 'async_trait>( &'life0 self, _request: Request<Streaming<Envelope>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::OpenChannelFromCocoonStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

LAND-PATCH B7-S6 P2: bidirectional streaming channel.

impl VineHost for MountainVinegRPCService

fn ApplicationState(&self) -> &dyn ApplicationStateAccess

Returns the embedder’s application state for handler use.

fn EmitToRenderer(&self, Channel: &str, Payload: Value)

Emits a JSON event on the named renderer channel. No-op for embedders that have no renderer (e.g. Air).

fn RendererEmitter(&self) -> Arc<dyn RendererEmitter>

Returns a cheap-to-clone renderer event sink. Used by handlers with long-lived flushers that need to emit from a background task without borrowing the full host.

fn IPCProvider(&self) -> Arc<dyn IPCProvider>

Returns the cross-channel IPC provider. Used by handlers that need to re-enter the IPC bus (e.g. tree-view registration that needs to call sky:replay-events).

fn UnregisterProvider(&self, Handle: u32)

Unregisters a provider by handle. Embedders that maintain a provider registry route this to their ProviderRegistration table; embedders without a registry silently discard.

fn RegisterCommandInRegistry(&self, CommandId: &str, SideCarIdentifier: &str)

Inserts a proxied command into the embedder’s command dispatch registry. SideCarIdentifier is the gRPC sidecar to proxy to (e.g. "cocoon-main"). No-op for embedders without a command registry.

fn UnregisterCommandInRegistry(&self, CommandId: &str)

Removes a command from the embedder’s dispatch registry. No-op for embedders without a command registry.

fn SpawnSendTextToTerminal(&self, TerminalId: u64, Text: String)

Spawns a background task that sends Text to the PTY identified by TerminalId. No-op for embedders without terminal support.

fn SpawnDisposeTerminal(&self, TerminalId: u64)

Spawns a background task that disposes the PTY identified by TerminalId. No-op for embedders without terminal support.

fn CreateTerminal<'a>( &'a self, Options: &'a Value, ) -> BoxFuture<'a, Option<Value>>

Creates a new PTY terminal with the given options JSON and returns Some({ "id": u64, "pid": u64, "name": string }) on success, None on failure or for embedders without terminal support.

fn RegisterScmInRegistry( &self, Handle: u32, ScmId: &str, Label: &str, ExtId: &str, )

Registers an SCM provider in the embedder’s ProviderRegistration table. Called once per vscode.scm.createSourceControl(...) invocation.

fn CreateSourceControl<'a>(&'a self, Payload: Value) -> BoxFuture<'a, ()>

Forwards a CreateSourceControl call to the embedder’s SourceControlManagementProvider. Errors are logged internally.

fn UpdateSourceControlGroup<'a>( &'a self, ScmHandle: u32, Payload: Value, ) -> BoxFuture<'a, ()>

Forwards an UpdateSourceControlGroup call to the embedder’s SourceControlManagementProvider. Errors are logged internally.

fn RegisterLanguageProvider( &self, Handle: u32, TypeName: &str, Payload: &Value, ) -> bool

Registers a language-feature provider by normalised type name. TypeName is the wire method stripped of register_ prefix and optional _provider suffix (e.g. "hover", "completion_item"). Returns true if the type was recognised and the registration was inserted; false for unknown type names (no-op embedders always return false).

fn UpdateScmGroupMarkers( &self, ScmHandle: u32, GroupId: &str, ResourceStates: &Value, )

Persists a resource-state snapshot for an SCM group in the embedder’s SCM marker registry. ScmHandle is the provider handle, GroupId identifies the group within that provider, and ResourceStates is the raw JSON array of resource state objects. No-op for embedders without SCM marker support.