lesavka/common/proto/lesavka.proto

// ───────────────────────────────────────── proto/lesavka.proto
syntax = "proto3";
package lesavka;

message KeyboardReport { bytes data = 1; }
message MouseReport    { bytes data = 1; }

message MonitorRequest {
  uint32 id = 1;
  uint32 max_bitrate = 2;
  uint32 requested_width = 3;
  uint32 requested_height = 4;
  uint32 requested_fps = 5;
  optional uint32 source_id = 6;
}
message VideoPacket    {
  uint32 id = 1;
  uint64 pts = 2;
  bytes data = 3;
  uint64 seq = 4;
  uint32 effective_fps = 5;
  uint64 dropped_total = 6;
  uint32 queue_depth = 7;
  uint32 server_source_gap_peak_ms = 8;
  uint32 server_send_gap_peak_ms = 9;
  uint32 server_queue_peak = 10;
  string server_encoder_label = 11;
  uint32 server_process_cpu_tenths = 12;
  // Shared client media-clock timestamp for the packet's capture estimate.
  uint64 client_capture_pts_us = 13;
  // Shared client media-clock timestamp when the packet entered the uplink queue.
  uint64 client_send_pts_us = 14;
  uint32 client_queue_depth = 15;
  uint32 client_queue_age_ms = 16;
}
message AudioPacket    {
  uint32 id = 1;
  uint64 pts = 2;
  bytes data = 3;
  uint64 seq = 4;
  // Shared client media-clock timestamp for the packet's capture estimate.
  uint64 client_capture_pts_us = 5;
  // Shared client media-clock timestamp when the packet entered the uplink queue.
  uint64 client_send_pts_us = 6;
  uint32 client_queue_depth = 7;
  uint32 client_queue_age_ms = 8;
}

message ResetUsbReply  { bool ok = 1; } // true = success

message PasteRequest   {
  bytes nonce = 1;
  bytes data = 2;
  bool encrypted = 3;
}
message PasteReply     { bool ok = 1; string error = 2; }
message CapturePowerState {
  bool available = 1;
  bool enabled = 2;
  string unit = 3;
  string detail = 4;
  uint32 active_leases = 5;
  string mode = 6;
  uint32 detected_devices = 7;
}
enum CapturePowerCommand {
  CAPTURE_POWER_COMMAND_UNSPECIFIED = 0;
  CAPTURE_POWER_COMMAND_AUTO = 1;
  CAPTURE_POWER_COMMAND_FORCE_ON = 2;
  CAPTURE_POWER_COMMAND_FORCE_OFF = 3;
}
message SetCapturePowerRequest {
  bool enabled = 1;
  CapturePowerCommand command = 2;
}

enum CalibrationAction {
  CALIBRATION_ACTION_UNSPECIFIED = 0;
  CALIBRATION_ACTION_RESTORE_DEFAULT = 1;
  CALIBRATION_ACTION_RESTORE_FACTORY = 2;
  CALIBRATION_ACTION_ADJUST_ACTIVE = 3;
  CALIBRATION_ACTION_BLIND_ESTIMATE = 4;
  CALIBRATION_ACTION_SAVE_ACTIVE_AS_DEFAULT = 5;
}

message CalibrationState {
  string profile = 1;
  int64 factory_audio_offset_us = 2;
  int64 factory_video_offset_us = 3;
  int64 default_audio_offset_us = 4;
  int64 default_video_offset_us = 5;
  int64 active_audio_offset_us = 6;
  int64 active_video_offset_us = 7;
  string source = 8;
  string confidence = 9;
  string updated_at = 10;
  string detail = 11;
}

message CalibrationRequest {
  CalibrationAction action = 1;
  int64 audio_delta_us = 2;
  int64 video_delta_us = 3;
  float observed_delivery_skew_ms = 4;
  float observed_enqueue_skew_ms = 5;
  string note = 6;
}

message UpstreamSyncState {
  uint64 session_id = 1;
  string phase = 2;
  optional uint64 latest_camera_remote_pts_us = 3;
  optional uint64 latest_microphone_remote_pts_us = 4;
  optional uint64 last_video_presented_pts_us = 5;
  optional uint64 last_audio_presented_pts_us = 6;
  optional float live_lag_ms = 7;
  optional float planner_skew_ms = 8;
  uint64 stale_audio_drops = 9;
  uint64 stale_video_drops = 10;
  uint64 skew_video_drops = 11;
  uint64 freshness_reanchors = 12;
  uint64 startup_timeouts = 13;
  uint64 video_freezes = 14;
  string last_reason = 15;
  optional float client_capture_skew_ms = 16;
  optional float client_send_skew_ms = 17;
  optional float server_receive_skew_ms = 18;
  optional float camera_client_queue_age_ms = 19;
  optional float microphone_client_queue_age_ms = 20;
  optional float camera_server_receive_age_ms = 21;
  optional float microphone_server_receive_age_ms = 22;
  optional float client_capture_abs_skew_p95_ms = 23;
  optional float client_send_abs_skew_p95_ms = 24;
  optional float server_receive_abs_skew_p95_ms = 25;
  optional float camera_client_queue_age_p95_ms = 26;
  optional float microphone_client_queue_age_p95_ms = 27;
  optional float sink_handoff_skew_ms = 28;
  optional float sink_handoff_abs_skew_p95_ms = 29;
  optional float camera_sink_late_ms = 30;
  optional float microphone_sink_late_ms = 31;
  optional float camera_sink_late_p95_ms = 32;
  optional float microphone_sink_late_p95_ms = 33;
  uint64 client_timing_window_samples = 34;
  uint64 sink_handoff_window_samples = 35;
}

message HandshakeSet  {
  bool camera = 1;
  bool microphone = 2;
  string camera_output = 3;
  string camera_codec = 4;
  uint32 camera_width = 5;
  uint32 camera_height = 6;
  uint32 camera_fps = 7;
  uint32 eye_width = 8;
  uint32 eye_height = 9;
  uint32 eye_fps = 10;
  string server_version = 11;
  string server_revision = 12;
}

message Empty          {}

service Relay {
  rpc StreamKeyboard   (stream KeyboardReport)   returns (stream KeyboardReport);
  rpc StreamMouse      (stream MouseReport)      returns (stream MouseReport);
  rpc CaptureVideo     (MonitorRequest)          returns (stream VideoPacket);
  rpc CaptureAudio     (MonitorRequest)          returns (stream AudioPacket);
  rpc StreamMicrophone (stream AudioPacket)      returns (stream Empty);
  rpc StreamCamera     (stream VideoPacket)      returns (stream Empty);

  rpc PasteText        (PasteRequest)            returns (PasteReply);
  rpc RecoverUsb       (Empty)                   returns (ResetUsbReply);
  rpc RecoverUac       (Empty)                   returns (ResetUsbReply);
  rpc RecoverUvc       (Empty)                   returns (ResetUsbReply);
  rpc ResetUsb         (Empty)                   returns (ResetUsbReply);
  rpc GetCapturePower  (Empty)                   returns (CapturePowerState);
  rpc SetCapturePower  (SetCapturePowerRequest)  returns (CapturePowerState);
  rpc GetCalibration   (Empty)                   returns (CalibrationState);
  rpc Calibrate        (CalibrationRequest)       returns (CalibrationState);
  rpc GetUpstreamSync  (Empty)                   returns (UpstreamSyncState);
}

service Handshake {
  rpc GetCapabilities (Empty)                    returns (HandshakeSet);
}