api.proto

syntax = "proto3";

import "google/protobuf/timestamp.proto";

package api;
option go_package = "/api";

message Command {
  reserved 250, 252, 253, 254, 255;

  // channel and session act as namespaces with 0 being global.
  // both session and channel must match for a client to receive a command.
  int32 channel = 1;

  // < 0 : all user sessions except abs(id)
  //   0 : all user sessions
  //   1 : internal message to conman
  // > 1 : user session with given id
  int32 session = 2;

  oneof body {
    // global messages
    // these should always be on channel 0

    OpenChannel openChan = 3;
    OpenChannelRes openChanRes = 4;

    CloseChannel closeChan = 5;
    CloseChannelRes closeChanRes = 6;

    ContainerState containerState = 9;
    PortOpen portOpen = 10;
    Toast toast = 11;
    // A protocol error. Will result in a disconnection.
    ProtocolError protocolError = 45;

    Redirect redirect = 12;

    AlwaysOn alwaysOn = 13;

    // service specific messages

    RunMain runMain = 16;
    Clear clear = 17;

    string eval = 20;
    string result = 21;
    string input = 22;
    string output = 23;
    string error = 24;
    string stderr = 46;
    string log = 47;

    SaneTerm saneTerm = 26;
    ResizeTerm resizeTerm = 27;

    State state = 28;

    OK ok = 30;

    File persist = 31;
    File persistMirror = 41;
    File write = 32;
    File remove = 33;
    Move move = 34;
    File tryRemove = 36;
    File mkdir = 39;
    File stat = 368;
    StatResult statRes = 369;

    TransferStart transferStart = 320;
    TransferChunk transferChunk = 321;
    TransferComplete transferComplete = 322;
    Transfer transferCancel = 323;
    Transfer transfer = 324;

    File read = 35;
    File readdir = 37;

    Files files = 38;
    File file = 40;

    CheckChanges checkChanges = 42;
    Files changedFiles = 43;

    LintResults lintResults = 44;

    ContainedTest runContainedTest = 70;
    TestResult testResult = 71;

    string debuggerStart = 90;
    RunMain debuggerStep = 91;
    DebugStatus debuggerStatus = 92;

    EnsurePackages ensurePackages = 100;

    Ping ping = 120;
    Pong pong = 121;
    Hello hello = 122;
    Goodbye goodbye = 123;

    Hint hint = 130;

    Connect connect = 150;
    Send send = 151;
    Recv recv = 152;
    Disconnect disconnect = 153;

    FileAuthReq fileAuthReq = 200;
    FileAuthRes fileAuthRes = 201;
    MultiFileAuthRes mutliFileAuthRes = 202;

    ListObjects listObjects = 205;
    ListObjectsResp listObjectsResp = 206;

    OTPacket ot = 220;
    OTStatus otstatus = 221;
    OTLinkFile otLinkFile = 222;
    OTLinkFileResponse otLinkFileResponse = 229;
    OTCursor otNewCursor = 223;
    OTCursor otDeleteCursor = 224;
    OTFetchRequest otFetchRequest = 225;
    OTFetchResponse otFetchResponse = 226;
    OTTransformSelectionRequest otTransformSelectionRequest = 227;
    OTTransformSelectionResponse otTransformSelectionResponse = 228;
    Flush flush = 251;

    Debug debug = 230;

    StartVCR startVCR = 231;
    ReadVCR readVCR = 232;
    VCRLog VCRLog = 233;

    Auth auth = 235;

    ExecInfo execInfo = 240;

    SubscribeFile subscribeFile = 256;
    FileEvent fileEvent = 257;

    // Presence service messages
    Roster roster = 260;
    User join = 261;
    User part = 262;
    OpenFile openFile = 263;
    FileOpened fileOpened = 264;
    FollowUser followUser = 265;
    UnfollowUser unfollowUser = 268;
    UpdateSessionTimestamp updateSessionTimestamp = 266;
    SessionTimestampUpdated sessionTimestampUpdated = 267;

    Exec exec = 270;

    PackageSearch packageSearch = 280;
    PackageSearchResp packageSearchResp = 281;
    PackageInfo packageInfo = 282;
    PackageInfoResp packageInfoResp = 283;
    PackageAdd packageAdd = 284;
    PackageRemove packageRemove = 285;
    PackageInstall packageInstall = 286;
    PackageListSpecfile packageListSpecfile = 287;
    PackageListSpecfileResp packageListSpecfileResp = 288;

    PackageCacheSave packageCacheSave = 289;

    ChatMessage chatMessage = 310;
    ChatTyping chatTyping = 311;
    ChatScrollback chatScrollback = 312;

    FSSnapshot fsSnapshot = 330;
    FSLock fsTakeLock = 331;
    FSLock fsReleaseLock = 332;

    bool hasCap = 335;

    // used to configure pid1 at runtime
    Pid1Config pid1Config = 340;

    Metrics metrics = 350;

    BootStatus bootStatus = 351;

    // metadata store
    ReadMetaRequest readMetaRequest = 360;
    ReadMetaResponse readMetaResponse = 384;

    WriteMetaRequest writeMetaRequest = 361;
    WriteMetaResponse writeMetaResponse = 385;

    AppendMetaRequest appendMetaRequest = 362;
    AppendMetaResponse appendMetaResponse = 386;

    // audio
    Audio audio = 363;


    PprofRequest pprofRequest = 364;
    PprofResponse pprofResponse = 365;

    Audio2 audio2 = 366;

    // used to set configure pty settings 
    PTYConfig PTYConfig = 367;

    // Debugger
    //
    // When the channel is created, a DebugSessions message will be sent to the
    // channel with the current list of all active sessions. When a session is
    // created / terminated, another DebugSessions message will be broadcast.

    // Request to start debugging the main file for the project. This will
    // atomically start a new session or join an existing one, identified by
    // the `session` name. Clients will receive a DebugState message followed by
    // a DebugMainReply on success, or an error on failure.
    //
    // Following a success, all channels will receive a DebugSessions with
    // the newly-created session. Also, further debug messages sent from the
    // client must contain the same session identifier.
    //
    // Clients can create any number of concurrent sessions. The main debugging
    // session is called "main" by convention.
    DebugMain debugMain = 370;
    DebugState debugState = 371;
    DebugMainReply debugMainReply = 372;

    // DebugInput can be sent to write to the adapter or the debuggee (as
    // stdin). This will reply with OK on success, or an error on failure.
    DebugInput debugInput = 373;

    // DebugOutput will be sent every time there is new output from the
    // debuggee (stdout / stderr) or the adapter.
    DebugOutput debugOutput = 374;

    // DebugStop can be sent to stop and clean up a debugger session. This will
    // reply with OK on success, or an error on failure.
    DebugStop debugStop = 375;

    // DebugLeave can be sent to stop receiving notifications for a debugger
    // session. This will reply with OK on success, or an error on failure.
    DebugLeave debugLeave = 376;

    DebugSessions debugSessions = 377;

    // DebugAddBreakpointRequest/DebugUpdateBreakpointRequest/DebugRemoveBreakpointRequest
    // can be sent to add/update/remove a breakpoint. A DebugBreakpointEvent
    // will be broadcast if the breakpoints changed. These will reply with OK on
    // success, or an error on failure.
    DebugAddBreakpointRequest debugAddBreakpointRequest = 380;
    DebugUpdateBreakpointRequest debugUpdateBreakpointRequest = 387;
    DebugRemoveBreakpointRequest debugRemoveBreakpointRequest = 381;

    // DebugBreakpointEvent is sent to all clients when a list of breakpoints
    // changes.
    DebugBreakpointEvent debugBreakpointEvent = 383;

    // DotReplit
    //
    // The dotreplit service lets the caller get the pre-parsed contents of
    // .replit in a proto format.

    // DotReplitGetRequest requests the contents of the .replit file. The
    // response will be a DotReplitGetResponse or an Error.
    DotReplitGetRequest dotReplitGetRequest = 378;
    DotReplitGetResponse dotReplitGetResponse = 379;
  }

  string ref = 1000;
}

message Audio { repeated int32 data = 1; }

message Audio2 {
  repeated sint32 data = 1;
  int64 samples = 2;
}

// Preconditions that need to be met before an operation starts. If they are
// not met, the operation will fail.
message Preconditions {
  // generation/metageneration are the expected generation numbers of the
  // metadata file in the storage layer. If set, the write will fail if the
  // generation does not match the expected value.
  int64 generation = 1;
  int64 metageneration = 2;

  // doesNotExist requires the file to not exist beforehand.
  bool doesNotExist = 3;
}

message ReadMetaRequest {
  string key = 1;
  bool exists = 2;
  bytes data = 3;
}

message ReadMetaResponse {
  string key = 1;
  bool exists = 2;
  bytes data = 3;

  // generation/metageneration are the generation numbers of the metadata file
  // in the storage layer.  Will always be non-zero if exists is true.
  int64 generation = 4;
  int64 metageneration = 5;
}

message WriteMetaRequest {
  reserved 3, 4;

  string key = 1;
  bytes data = 2;

  // Preconditions that need to be met before the file is written to.
  Preconditions preconditions = 5;
}

message WriteMetaResponse {
  // generation/metageneration are the new generation numbers of the metadata
  // file in the storage layer after being written to.
  int64 generation = 1;
  int64 metageneration = 2;
}

message AppendMetaRequest {
  reserved 3, 4;

  string key = 1;
  bytes data = 2;

  // Preconditions that need to be met before the file is appended to.
  Preconditions preconditions = 5;
}

message AppendMetaResponse {
  // generation/metageneration are the new generation numbers of the metadata
  // file in the storage layer after being written to.
  int64 generation = 1;
  int64 metageneration = 2;
}

message BootStatus {
  enum Stage {
    HANDSHAKE = 0;
    ACQUIRING = 3;
    COMPLETE = 4;
    PROXY = 5;
    PULL_FILES = 6;
    LOAD_BLOCK = 7;
    RETRY = 8;
  };

  Stage stage = 1;

  // progress/total is context dependant. Most stages have no progress info,
  // this is sent as 0/0 (the default value).
  uint32 progress = 2;
  uint32 total = 3;
}

message Pid1Config {
  string cwd = 1;
  string language = 2;
  map<string, string> env = 3;
}

message FSLock { string name = 1; }

message FSSnapshot {}

message SubscribeFile { repeated File files = 1; }

message FileEvent {
  File file = 1;

  // when the Op is a Move dest is set to the destination of the move.
  File dest = 3;

  enum Op {
    Create = 0;
    Move = 1;
    Remove = 2;
    Modify = 3;
  }
  Op op = 2;
}

message Flush {}

message OTLinkFile {
  File file = 1;
  bool highConsistency = 2;
  // The service will now always consider modtime of the file when
  // comparing history with disk content.
  bool OBSOLETE_useModTime = 3 [deprecated = true];
}

// OTLinkFileResponse contains the latest OT
// version as well as the linked file, with path and contents populated.
message OTLinkFileResponse {
  uint32 version = 1;
  File linkedFile = 2;
}

message Auth {
  string token = 1;
  string containerID = 2;
}

message VCREntry {
  uint64 timestamp = 1;

  enum Direction {
    IN = 0;
    OUT = 1;
  }
  Direction direction = 2;

  Command command = 3;

  string uid = 4;
  string replid = 5;
}

message StartVCR {}

message ReadVCR {}

message VCRLog {
  repeated VCREntry log = 1;
  File logfile = 2;
}

message ExecInfo {
  repeated string command = 1;
  string reason = 2;
}

message Debug { string text = 1; }

enum FileAuthMethod {
  GET = 0;
  HEAD = 1;
  PUT = 2;
  DELETE = 3;
}

message FileAuthReq {
  File file = 1;
  FileAuthMethod method = 2;
}

message MultiFileAuthRes {
  FileAuthRes put = 1;
  FileAuthRes del = 2;
  FileAuthRes get = 3;
}

message FileAuthRes {
  File file = 1;

  string url = 2;
  FileAuthMethod method = 3;

  int64 expire = 4;

  string error = 5;
  // Whether this error applies to the whole repl or only to the requested file.
  bool replError = 7;
}

message ListObjects { string prefix = 1; }

message ListObjectsResp { repeated string objects = 1; }

message Disconnect { string error = 1; }

message Send { bytes buff = 1; }

message Recv { bytes buff = 1; }

message Connect {
  string proto = 1;
  string addr = 2;
}

message Hint { string text = 1; }

message Ping {}
message Pong {}

message Hello {
  uint32 userid = 1;
  string username = 2;
  string token = 3;
}

message Goodbye {}

enum State {
  Stopped = 0;
  Running = 1;
}

message CheckChanges {}

message EnsurePackages {
  bool install = 1;
  File file = 2;
}

message Start {}

message DebugStatus {
  bool done = 1;
  repeated StackFrame stack = 2;
}

message StackFrame {
  string function = 1;
  uint32 line = 2;
}

message ContainedTest {
  File suite = 1;
  repeated File project = 2;
}

message TestResult {
  bool passed = 1;
  string stderr = 2;
  repeated TestFailure fails = 3;
}

message TestFailure {
  string name = 1;
  string trace = 2;
}

message ResizeTerm {
  uint32 rows = 1;
  uint32 cols = 2;
}

message SaneTerm {}

message LintResults { repeated LintResult results = 1; }

message LintResult {
  string text = 1;
  int32 row = 2;
  int32 column = 3;
  string type = 4;
}

message OK {}

message Move {
  string oldPath = 1;
  string newPath = 2;
}

message Files { repeated File files = 1; }

message StatResult {
  bool exists = 1;
  File.Type type = 2;
  int64 size = 3;
  string fileMode = 4;
  int64 modTime = 5;
}

message File {
  string path = 1;
  enum Type {
    REGULAR = 0;
    DIRECTORY = 1;
  }
  Type type = 2;
  bytes content = 3;
}

// Transfer represents an active file transfer.
message Transfer {
  // The opaque id the server assigned to this transfer. Should be used by the client
  // for every call that refers to this transfer.
  string id = 1;
}

// TransferStart is used to initiate a new file transfer. The server is supposed
// to reply to this message with a Transfer, that contains the id to refer to it.
// Transfers are used to send large files to the server, the client can split 
// content into chunks and send them one-by-one.
message TransferStart {
  // Relative location for the destination file (same as File.path).
  string path = 1;
  // The expected file size of the file. The server can refuse to initiate
  // the transfer if the file size is too large.
  int64 size = 2;
}

// TransferChunk is used by client to send a chunk of a file. The content will be
// appended to the end of the current buffer file. The server can refuse a chunk
// if it would result in a file larger than initially expected.
message TransferChunk {
  // The opaque id the server assigned to this transfer
  string id = 1;
  // The content to append.
  bytes content = 2;
}

// TransferComplete is used by client to indicate that it's done sending the file
// and the server is supposed to finalize the transfer: atomically create a new
// file in the `path` specified earlier. The client needs to specify the checksum,
// the server will abort the transfer if the checksum doesn't match, or if the
// total file size is different from the specified via TransferStart.
message TransferComplete {
  // The opaque id the server assigned to this transfer.
  string id = 1;
  // CRC-32-IEEE checksum of the whole file content.
  uint32 crc32 = 2;
}

message Clear {}

message Toast { string text = 1; }

message ProtocolError { string text = 1; }

// Redirect indicates that a client should attempt to connect through another
// URL. This is needed since most browser WebSockets implementations do not
// support following standard HTTP redirects.
message Redirect {
  // The URL to try again. If empty, the negotiation to figure out the URL for
  // a repl needs to start from scratch.
  string url = 1;
}

// AlwaysOn tells conman that always on should be enabled or disabled.
message AlwaysOn {
  bool enable = 1;
}

message RunMain {}

message OpenChannel {
  string service = 1;
  string name = 2;

  enum Action {
    CREATE = 0;
    ATTACH = 1;
    ATTACH_OR_CREATE = 2;
  }
  Action action = 3;

  int32 id = 4;
}

message OpenChannelRes {
  int32 id = 1;

  enum State {
    CREATED = 0;
    ATTACHED = 1;
    ERROR = 2;
  }
  State state = 2;

  string error = 3;
}

message CloseChannel {
  int32 id = 1;

  enum Action {
    DISCONNECT = 0;
    TRY_CLOSE = 1;
    CLOSE = 2;
  }
  Action action = 2;
}

message CloseChannelRes {
  int32 id = 1;

  enum Status {
    DISCONNECT = 0;
    CLOSE = 1;
    NOTHING = 2;
  }
  Status status = 2;
}

message ContainerState {
  enum State {
    SLEEP = 0;
    READY = 1;
  }
  State state = 1;
}

message PortOpen {
  bool forwarded = 1;
  uint32 port = 2;
  string address = 3;
}

message OTFetchRequest {
  uint32 versionFrom = 1;
  uint32 versionTo = 2;
}

message OTFetchResponse {
  repeated OTPacket packets = 1;
}

// OTTransformSelectionRequest asks the OT Service to transform a selection 
// (represented by a start and end index) from one version to another by 
// applying OT ops.
message OTTransformSelectionRequest {
  uint32 indexStart = 1;
  uint32 indexEnd = 2;

  uint32 versionFrom = 3;
  uint32 versionTo = 4;
}

// When the OT Service successfully transforms a selection, the resulting 
// indexStart, indexEnd pair is returned
message OTTransformSelectionResponse {
  // selection
  uint32 indexStart = 1;
  uint32 indexEnd = 2;
  
  // version
  uint32 version = 3;
}

message OTPacket {
  // so here's the deal. Once uppon a time `spookyVersion` was `version` and things
  // worked okay. Then one day someone came along and decided our handling of
  // version 0 was all kinds of messed up. Sending a version that already existed
  // never transformed the packet by that particular version. It was as if
  // `version` was treated as `version + 1`. This could not stand and thus the
  // great rift of versions was created. `version` does the right thing and
  // `spookyVersion` maintains backwards compatibility.
  uint32 spookyVersion = 1;
  uint32 version = 5;

  repeated OTRuneTransformOp ops = 2;
  uint32 crc32 = 3;
  google.protobuf.Timestamp committed = 4;

  uint32 nonce = 6;
}

message OTRuneTransformOp {
  oneof op {
    uint32 skip = 1;
    uint32 delete = 2;
    string insert = 3;
  }
}
message OTStatus {
  string contents = 1;
  uint32 version = 2;
  File linkedFile = 3;
  repeated OTCursor cursors = 4;
}

message OTCursor {
  uint32 position = 1;
  uint32 selectionStart = 2;
  uint32 selectionEnd = 3;
  User user = 4;
  string id = 5;
}

message ChatMessage {
  string username = 1;
  string text = 2;
}

message ChatTyping {
  string username = 1;
  bool typing = 2;
}

// A user connected to a multiplayer session
message User {
  uint32 id = 1;
  string name = 2;
  repeated string roles = 3;
  int32 session = 4;
}

// When the presence channel is created, a roster will be
// sent to the channel with the current list of
// connected users and their active files
message Roster {
  repeated User user = 1;
  repeated FileOpened files = 2;
}

// OpenFile can be sent to notify other connected
// clients that the user has switched files
message OpenFile {
  string file = 1;
}

// FileOpened is sent by pid1 to the client any time
// another connected user sends the OpenFile message
message FileOpened {
  uint32 userId = 1;
  string file = 2;
  int32 session = 3;
  google.protobuf.Timestamp timestamp = 4;
}

// Updates the timestamp on the current session
// which indicates that this is the user's most recent,
// and therefore active, session.
message UpdateSessionTimestamp {}

// Indicates that another user's session timestamp has been updated
// which implies that it is that user's active session.
// Every client will receive this message from pid1 even if they're
// not following a user so that their local store is always up to date.
message SessionTimestampUpdated {
  int32 session = 1;
  google.protobuf.Timestamp timestamp = 2;
}

// Notify a user that their cursor is being followed.
message FollowUser {
  int32 session = 1;
}

// Notify a user that their cursor is being unfollowed.
message UnfollowUser {
  int32 session = 1;
}

message Exec {
  repeated string args = 1;
  map<string, string> env = 2;
  // Blocking is deprecated. Prefer to use lifecycle = BLOCKING instead.
  bool blocking = 3 [deprecated = true];

  enum Lifecycle {
    // NON_BLOCKING is the default. This lets the process run in the background.
    NON_BLOCKING = 0;
    // BLOCKING starts and waits until the process has finished executing.
    BLOCKING = 1;
    // STDIN starts the process in the background and opens a pipe to stdin.
    // TODO: Add an explicit message to be able to close the stdin.
    STDIN = 2;
  };
  Lifecycle lifecycle = 6;


  // splitStderr can be set to true in order to send stderr as separate
  // messages. Note that there is no synchronization between stdout and stderr.
  bool splitStderr = 4;

  // splitLogs can be set to true if the underlying program will log
  // JSON-formatted logs to the file descriptor pointed to by the `LOG_FD`
  // environment variable available to the child process. These logs will be
  // send through separate messages.
  bool splitLogs = 5;
}

message Package {
  // Used always.
  string name = 1;
  // Used only for add and remove.
  string spec = 2;
  // Used only for search and info.
  string description = 10;
  string version = 11;
  string homepageURL = 12;
  string documentationURL = 13;
  string sourceCodeURL = 14;
  string bugTrackerURL = 15;
  string author = 16;
  string license = 17;
  repeated Package dependencies = 18;
}

message PackageSearch { string query = 1; }

message PackageSearchResp { repeated Package results = 1; }

message PackageInfo { Package pkg = 1; }

message PackageInfoResp { Package pkg = 1; }

message PackageAdd { repeated Package pkgs = 1; }

message PackageRemove { repeated Package pkgs = 1; }

message PackageInstall {}

message PackageListSpecfile {}

message PackageListSpecfileResp { repeated Package pkgs = 1; }

message PackageCacheSave {}

message ChatScrollback { repeated ChatMessage scrollback = 1; }

message Metrics { repeated bytes prometheusMetricFamilies = 1; }

message PprofRequest {
  string id = 1;
  oneof body {
    PprofCpuProfileRequest pprofCpuProfileRequest = 2;
    PprofHeapProfileRequest pprofHeapProfileRequest = 3;
    PprofAllocsProfileRequest pprofAllocsProfileRequest = 4;
    PprofBlockProfileRequest pprofBlockProfileRequest = 5;
    PprofMutexProfileRequest pprofMutexProfileRequest = 6;
  }
}

message PprofAllocsProfileRequest {
  bool debug = 1;
}

message PprofBlockProfileRequest {
  bool debug = 1;
}

message PprofCpuProfileRequest {
  int64 seconds = 1;
}

message PprofHeapProfileRequest {
  bool gc = 1;
  bool debug = 2;
}

message PprofMutexProfileRequest {
  bool debug = 1;
}

message PprofResponse {
  string id = 1;
  bytes profile = 2;
}

// Message used to configure PTY
message PTYConfig {
  // Whether "PipeMode" should be enabled or not
  // PipeMode is the equivelent of stty raw icrnl isig -echo. 
  // This is designed for comparing and output - the output 
  // should be as close as possible to its original state.  
  bool pipeMode = 1;
}

// The message used to request to start a new debug session with the main
// program (i.e. the same one that would be run with the Run button) as
// debuggee.
message DebugMain {
  // The user-chosen session name. This same session must be provided in all
  // other debugger-related messages. By convention, the "main" session is the
  // default one.
  string session = 1;
  // Whether this session is read-only. Those sessions won't be able to change
  // the execution state (play, pause, change breakpoints, etc.).
  bool readOnly = 2;
}

// The reply message of DebugMain.
message DebugMainReply {
  // If the DebugMain request was the first one for the session, joined will be
  // false. Otherwise, joined will be true. The protocol may also have enough
  // hints to convey this.
  bool joined = 1;
  enum Protocol {
    // The adapter speaks the Debug Adapter Protocol:
    // https://microsoft.github.io/debug-adapter-protocol/
    DAP = 0;
  }
  // The protocol that the adapter is using.
  Protocol protocol = 2;
}

// The state of a debug session. This is sent before the reply to DebugMain is
// sent, as well as whenever the adapter exits.
message DebugState {
  string session = 1;
  State state = 2;
}

// The message used to write to the debuggee or the adapter.
message DebugInput {
  string session = 1;
  oneof stream {
    // The UTF-8 encoded input for the debuggee.
    string input = 2;

    // The UTF-8 encoded input for the adapter, using the protocol described by
    // DebugMainReply.
    string adapterInput = 3;
  }
}

// The message used to read from the debuggee or the adapter.
message DebugOutput {
  string session = 1;
  oneof stream {
    // The UTF-8 encoded output from the debuggee.
    string output = 2;

    // The UTF-8 encoded output from the adapter, using the protocol described by
    // DebugMainReply.
    string adapterOutput = 3;
  }
}

// The message used to request the adapter and debuggee to stop. This is needed
// because debuggers/adapters can be put in a state where they are not able to
// receive requests to stop at the protocol level and need to be forcefully
// stopped.
//
// The implementation will first try to gracefully terminate the session by
// sending an appropriate protocol message, and then send a SIGKILL signal to
// both the debuggee and the adapter if they don't exit within a certain time
// limit.
message DebugStop {
  string session = 1;
}

// The message used to request to stop receiving notifications for a debugger
// session. This can be used to "close" a debugger session without needing to
// close the whole crosis session.
message DebugLeave {
  string session = 1;
}

// The message sent by the server to signal the current list of sessions. This
// is also sent upon the creation of the debugger channel, as well as every
// time a new session is created or terminated.
message DebugSessions {
  map<string, State> sessions = 1;
}

// The message used to request to get the contents of the `.replit` file.
message DotReplitGetRequest {
}

// The message sent by the server with the contents of the `.replit` file.
message DotReplitGetResponse {
  DotReplit dotReplit = 1;
}

// The message used to request to add a new breakpoint.
message DebugAddBreakpointRequest {
  string path = 1;

  // The OT version and 0-based index (in Unicode codepoints) in which the
  // breakpoint is inserted. It is recommended to attach the breakpoint to the
  // first non-whitespace character in the line, so that it better tracks the
  // breakpoint location.
  uint32 otVersion = 2;
  uint32 otIndex = 3;

  // When a breakpoint is session-local, two things happen:
  // - The OT stream is ignored. This means that this means that the
  //   breakpoint's line will not be updated when there are new OT operations.
  // - The breakpoint is not saved to the `.breakpoints` file.
  bool sessionLocal = 6;

  // The 1-indexed line number in which the debugger breakpoint will be added.
  // This is used as a fallback in case the file does not have OT history
  // available.
  int32 line = 4;

  // The optional log message that will be used as a logpoint instead of a
  // breakpoint. Logpoints are different from breakpoints in that the backend
  // does not 'break' (stop), and instead logs the message. Expressions within
  // {} are interpolated.  This is only honored by a debug adapter if the
  // capability `supportsLogPoints` is true.
  string logMessage = 5;
}

// The message used to request to update an existing breakpoint.
message DebugUpdateBreakpointRequest {
  string breakpointId = 1;

  // The optional log message that will be used as a logpoint instead of a
  // breakpoint. Logpoints are different from breakpoints in that the backend
  // does not 'break' (stop), and instead logs the message. Expressions within
  // {} are interpolated.  This is only honored by a debug adapter if the
  // capability `supportsLogPoints` is true.
  string logMessage = 2;
}

// The message used to request to remove an existing breakpoint.
message DebugRemoveBreakpointRequest {
  string breakpointId = 2;
}

// The message used to notify about when the breakpoints for a file changed.
message DebugBreakpointEvent {
  // The repl-relative path of the file.
  string path = 1;
  // The absolute path of the file.
  string absolutePath = 3;
  repeated DebugBreakpoint breakpoints = 2;
}

// The message that represents a single breakpoint for a file.
message DebugBreakpoint {
  // The globally-unique ID for a breakpoint.
  string breakpointId = 1;
  // The 1-indexed line number for the breakpoint.
  int32 line = 2;
  // The OT version and 0-based index (in Unicode codepoints) in which the
  // breakpoint is inserted. It is recommended to attach the breakpoint to the
  // first non-whitespace character in the line, so that it better tracks the
  // breakpoint location.
  uint32 otVersion = 3;
  uint32 otIndex = 4;
  bool sessionLocal = 6;
  string logMessage = 5;
}

// DotReplit is a .proto representation of types.DotReplit.
message DotReplit {
  Exec run = 1;
  Exec compile = 2;
  DebuggerConfig debugger = 3;
  string language= 4;
  Exec onBoot = 5;
  DotReplitPackager packager = 6;
  DotReplitInterp interpreter = 7;
  string entrypoint = 8;
}

message DotReplitInterp {
  Exec command = 1;
  bytes prompt = 2;
}

// DotReplitPackager is a .proto representation of types.Packager.
message DotReplitPackager {
  Exec afterInstall = 1;

  string language = 4;
  DotReplitPackagerFeatures features = 5;
  map<string, string> env = 6;

  repeated string ignoredPaths = 2;
  repeated string ignoredPackages = 3;
}

message DotReplitPackagerFeatures {
  bool packageSearch = 1;
  bool guessImports = 2;
}

// DebuggerConfig is the configuration for the debugger. Right now,
// only the relevant fields are exposed (whether it's enabled).
message DebuggerConfig {
  bool support = 1;
}