space.proto

syntax = "proto3";


import "google/protobuf/empty.proto";
import "google/api/annotations.proto";

package space;

option go_package = ".;pb";

//See here for more info about the google.api.http spec: https://github.com/googleapis/googleapis/blob/master/google/api/http.proto#L46

// SpaceApi service
service SpaceApi {
  // Get all folder or files in the default bucket. It fetches all subdirectories too.
  rpc ListDirectories(ListDirectoriesRequest) returns (ListDirectoriesResponse) {
    option (google.api.http) = {
      get: "/v1/directories/all"
    };
  }

  // Get the folder or files in the path directory.
  // Unlike ListDirectories, this only returns immediate children at path.
  rpc ListDirectory(ListDirectoryRequest) returns (ListDirectoryResponse) {
    option (google.api.http) = {
      get: "/v1/directories"
    };
  }

  // Generate Key Pair for current account.
  // This will return error if daemon account already has keypairs
  rpc GenerateKeyPair(GenerateKeyPairRequest) returns (GenerateKeyPairResponse) {
    option (google.api.http) = {
      post: "/v1/keypairs/generate"
      body: "*"
    };
  }

  rpc GetStoredMnemonic(GetStoredMnemonicRequest) returns (GetStoredMnemonicResponse) {
    option (google.api.http) = {
      get: "/v1/keypairs/mnemonic"
    };
  }

  // Restores a keypair given a mnemonic.
  // This will override any existing key pair
  rpc RestoreKeyPairViaMnemonic(RestoreKeyPairViaMnemonicRequest) returns (RestoreKeyPairViaMnemonicResponse) {
    option (google.api.http) = {
      post: "/v1/keypairs/restoreWithMnemonic"
      body: "*"
    };
  }

  rpc DeleteKeyPair(DeleteKeyPairRequest) returns (DeleteKeyPairResponse) {
    option (google.api.http) = {
      post: "/v1/keypairs/delete"
      body: "*"
    };
  }

  // Force Generation of KeyPair. This will override existing keys stored in daemon.
  rpc GenerateKeyPairWithForce(GenerateKeyPairRequest) returns (GenerateKeyPairResponse) {
    option (google.api.http) = {
      post: "/v1/keypairs/forceGenerate"
      body: "*"
    };
  }

  rpc GetPublicKey(GetPublicKeyRequest) returns (GetPublicKeyResponse) {
    option (google.api.http) = {
      post: "/v1/publicKey"
      body: "*"
    };
  }

  // Subscribe to file events. This streams responses to the caller
  rpc Subscribe(google.protobuf.Empty) returns (stream FileEventResponse) {
    option (google.api.http) = {
      get: "/v1/subscriptions/file"
    };
  }

  // Subscribe to textile events. This streams responses to the caller
  rpc TxlSubscribe(google.protobuf.Empty) returns (stream TextileEventResponse) {
    option (google.api.http) = {
      get: "/v1/subscriptions/textile"
    };
  }

  // Open a file in the daemon.
  // Daemon keeps track of all open files and closes them if no activity is noticed after a while
  rpc OpenFile(OpenFileRequest) returns (OpenFileResponse) {
    option (google.api.http) = {
      post: "/v1/files/open"
      body: "*"
    };
  }

  // Removes a file or dir from a bucket
  rpc RemoveDirOrFile(RemoveDirOrFileRequest) returns (RemoveDirOrFileResponse) {
    option (google.api.http) = {
      delete: "/v1/files"
    };
  }

  // Generates a copy of the file that's accessible through IPFS gateways
  rpc GeneratePublicFileLink(GeneratePublicFileLinkRequest) returns (GeneratePublicFileLinkResponse) {
    option (google.api.http) = {
      post: "/v1/buckets/{bucket}/generatePublicFileLink"
      body: "*"
    };
  }

  // Gets the files that are shared with this recipient
  rpc GetSharedWithMeFiles(GetSharedWithMeFilesRequest) returns (GetSharedWithMeFilesResponse) {
    option (google.api.http) = {
      get: "/v1/files/sharedWithMe"
    };
  }

  // Gets the files that are shared by the sender
  rpc GetSharedByMeFiles(GetSharedByMeFilesRequest) returns (GetSharedByMeFilesResponse) {
    option (google.api.http) = {
      get: "/v1/files/sharedByMe"
    };
  }

  // Open an encrypted public shared file in the daemon.
  // This requires the decryption key and file hash/cid to work
  rpc OpenPublicFile(OpenPublicFileRequest) returns (OpenPublicFileResponse) {
    option (google.api.http) = {
      get: "/v1/files/openPublic"
    };
  }

  // Adds items (files/folders) to be uploaded to the bucket.
  rpc AddItems(AddItemsRequest) returns (stream AddItemsResponse) {
    option (google.api.http) = {
      post: "/v1/files"
      body: "*"
    };
  }

  // Creates a folder/directory at the specified path
  rpc CreateFolder(CreateFolderRequest) returns (CreateFolderResponse) {
    option (google.api.http) = {
      post: "/v1/directories"
      body: "*"
    };
  }

  // Toggle FUSE drive to be mounted or unmounted
  rpc ToggleFuseDrive(ToggleFuseRequest) returns (FuseDriveResponse) {
    option (google.api.http) = {
      post: "/v1/toggleFuse"
      body: "*"
    };
  }

  // Get status of FUSE drive. If mounted or unmounted
  rpc GetFuseDriveStatus(google.protobuf.Empty) returns (FuseDriveResponse) {
    option (google.api.http) = {
      get: "/v1/fuse"
    };
  }

  // Create a new bucket owned by current user (aka keypair)
  rpc CreateBucket(CreateBucketRequest) returns (CreateBucketResponse) {
    option (google.api.http) = {
      post: "/v1/buckets"
      body: "*"
    };
  }

  // Backup Key by Passphrase
  rpc BackupKeysByPassphrase(BackupKeysByPassphraseRequest) returns (BackupKeysByPassphraseResponse) {
    option (google.api.http) = {
      post: "/v1/passphrases/backup"
      body: "*"
    };
  }

  // Recover Keys by Passphrase
  rpc RecoverKeysByPassphrase(RecoverKeysByPassphraseRequest) returns (RecoverKeysByPassphraseResponse) {
    option (google.api.http) = {
      post: "/v1/passphrases/recover"
      body: "*"
    };
  }

  // Tests a passphrase to see if it matches the one previously used
  rpc TestKeysPassphrase(TestKeysPassphraseRequest) returns (TestKeysPassphraseResponse) {
    option (google.api.http) = {
      post: "/v1/passphrases/test"
      body: "*"
    };
  }

  rpc CreateLocalKeysBackup(CreateLocalKeysBackupRequest) returns (CreateLocalKeysBackupResponse) {
    option (google.api.http) = {
      post: "/v1/localBackups/backup"
      body: "*"
    };
  }

  rpc RecoverKeysByLocalBackup(RecoverKeysByLocalBackupRequest) returns (RecoverKeysByLocalBackupResponse) {
    option (google.api.http) = {
      post: "/v1/localBackups/recover"
      body: "*"
    };
  }

  // Share bucket
  rpc ShareBucket(ShareBucketRequest) returns (ShareBucketResponse) {
    option (google.api.http) = {
      post: "/v1/buckets/{bucket}/share"
      body: "*"
    };
  }

  // Join bucket
  rpc JoinBucket(JoinBucketRequest) returns (JoinBucketResponse) {
    option (google.api.http) = {
      post: "/v1/buckets/{bucket}/join"
      body: "*"
    };
  }

  // Share bucket via public key using Textile Hub inboxing
  rpc ShareFilesViaPublicKey(ShareFilesViaPublicKeyRequest) returns (ShareFilesViaPublicKeyResponse) {
    option (google.api.http) = {
      post: "/v1/shareFilesViaPublicKey"
      body: "*"
    };
  }

  // Remove public keys for shared files in buckets
  rpc UnshareFilesViaPublicKey(UnshareFilesViaPublicKeyRequest) returns (UnshareFilesViaPublicKeyResponse) {
    option (google.api.http) = {
      post: "/v1/unshareFilesViaPublicKey"
      body: "*"
    };
  }

  rpc HandleFilesInvitation(HandleFilesInvitationRequest) returns (HandleFilesInvitationResponse) {
    option (google.api.http) = {
      post: "/v1/filesinvitation/{invitationID}"
      body: "*"
    };
  }

  rpc NotificationSubscribe(google.protobuf.Empty) returns (stream NotificationEventResponse) {
    option (google.api.http) = {
      get: "/v1/subscriptions/notification"
    };
  }

  rpc ListBuckets(ListBucketsRequest) returns (ListBucketsResponse) {
    option (google.api.http) = {
      get: "/v1/buckets"
    };
  }

  rpc GetNotifications(GetNotificationsRequest) returns (GetNotificationsResponse) {
    option (google.api.http) = {
      get: "/v1/notifications"
    };
  }


  rpc ReadNotification(ReadNotificationRequest) returns (ReadNotificationResponse) {
    option (google.api.http) = {
      post: "/v1/notifications/{ID}/read"
      body: "*"
    };
  }

  rpc DeleteAccount(DeleteAccountRequest) returns (DeleteAccountResponse) {
    option (google.api.http) = {
      post: "/v1/deleteAccount"
      body: "*"
    };
  }

  rpc ToggleBucketBackup(ToggleBucketBackupRequest) returns (ToggleBucketBackupResponse) {
    option (google.api.http) = {
      post: "/v1/backup"
      body: "*"
    };
  }

  rpc BucketBackupRestore(BucketBackupRestoreRequest) returns (BucketBackupRestoreResponse) {
    option (google.api.http) = {
      post: "/v1/backup/restore"
      body: "*"
    };
  }

  rpc GetUsageInfo(GetUsageInfoRequest) returns (GetUsageInfoResponse) {
    option (google.api.http) = {
      get: "/v1/usage"
    };
  }

  rpc GetAPISessionTokens(GetAPISessionTokensRequest) returns (GetAPISessionTokensResponse) {
    option (google.api.http) = {
      get: "/v1/apiSessionTokens"
    };
  }

  // Returns a list of addresses / public keys of clients to which files where shared or received, ordered by date
  rpc GetRecentlySharedWith(GetRecentlySharedWithRequest) returns (GetRecentlySharedWithResponse) {
    option (google.api.http) = {
      get: "/v1/sharedWithList"
    };
  }

  // This will set the last read timestamp for the user so that the client
  // can check if newer notifications are present for UX
  rpc SetNotificationsLastSeenAt(SetNotificationsLastSeenAtRequest) returns (SetNotificationsLastSeenAtResponse) {
    option (google.api.http) = {
      post: "/v1/notifications/lastSeenAt"
      body: "*"
    };
  }

  // Search for files across all users bucket
  rpc SearchFiles(SearchFilesRequest) returns (SearchFilesResponse) {
    option (google.api.http) = {
      get: "/v1/search/files"
    };
  }

  // Initialize master app token
  // App tokens are used to authorize scoped access to a range of methods
  // Master token can only be generated once and has access to all methods
  rpc InitializeMasterAppToken(InitializeMasterAppTokenRequest) returns (InitializeMasterAppTokenResponse) {
    option (google.api.http) = {
      post: "/v1/appTokens/master"
      body: "*"
    };
  }

  // Generates an app token with scoped access.
  rpc GenerateAppToken(GenerateAppTokenRequest) returns (GenerateAppTokenResponse) {
    option (google.api.http) = {
      post: "/v1/appTokens"
      body: "*"
    };
  }
}

message SearchFilesRequest {
  string query = 1;
}

message SearchFilesResponse {
  repeated SearchFilesDirectoryEntry entries = 1;
  string query = 2;
}

message SearchFilesDirectoryEntry {
  ListDirectoryEntry entry = 1;
  string dbId = 2;
  string bucket = 3;
}

message SetNotificationsLastSeenAtRequest {
  int64 timestamp = 1;
}

message SetNotificationsLastSeenAtResponse {}

message GetSharedWithMeFilesRequest {
  string seek = 1;
  int64 limit = 2;
}

message GetSharedWithMeFilesResponse {
  repeated SharedListDirectoryEntry items = 1;
  string nextOffset = 2;
}

message GetSharedByMeFilesRequest {
  string seek = 1;
  int64 limit = 2;
}

message GetSharedByMeFilesResponse {
  repeated SharedListDirectoryEntry items = 1;
  string nextOffset = 2;
}

message GetUsageInfoRequest {}

message GetUsageInfoResponse {
  uint64 localStarogeUsed = 1;
  uint64 localBandwidthUsed = 2;
  uint64 spaceStorageUsed = 3;
  uint64 spaceBandwidthUsed = 4;
  uint64 usageQuota = 5;
}

message ToggleBucketBackupRequest {
  string bucket = 1;
  bool backup = 2;
}

message ToggleBucketBackupResponse {}

message BucketBackupRestoreRequest {
  string bucket = 1;
}

message BucketBackupRestoreResponse {}

message ListDirectoriesRequest {
  string bucket = 1;
  bool omitMembers = 2;
}

message FileMember {
  string publicKey = 1;
  string address = 2;
}

message ListDirectoryEntry {
  string path = 1;
  bool isDir = 2;
  string name = 3;
  string sizeInBytes = 4;
  string created = 5;
  string updated = 6;
  string fileExtension = 7;
  string ipfsHash = 8;
  bool isLocallyAvailable = 9;
  int64 backupCount = 10;
  repeated FileMember members = 11;
  bool isBackupInProgress = 12;
  bool isRestoreInProgress = 13;
}

message SharedListDirectoryEntry {
  ListDirectoryEntry entry = 1;
  string dbId = 2;
  string bucket = 3;
  bool isPublicLink = 4;
  string sharedBy = 5;
}

message ListDirectoriesResponse {
  repeated ListDirectoryEntry entries = 1;
}

message ListDirectoryRequest {
  string path = 1;
  string bucket = 2;
  bool omitMembers = 3;
}

message ListDirectoryResponse {
  repeated ListDirectoryEntry entries = 1;
}

message CreateBucketRequest {
  string slug = 1;
}

message BucketMember {
  string address = 1;
  string publicKey = 2;
  bool isOwner = 3;
  bool hasJoined = 4;
}

message Bucket {
  string key = 1;
  string name = 2;
  string path = 3;
  int64 createdAt = 4;
  int64 updatedAt = 5;
  repeated BucketMember members = 6;
  bool isPersonalBucket = 7;
  bool isBackupEnabled = 8;
  int32 itemsCount = 9;
}

message CreateBucketResponse {
  Bucket bucket = 1;
}

message GenerateKeyPairRequest {}

message GenerateKeyPairResponse {
  string mnemonic = 1;
}

message GetStoredMnemonicRequest {}

message GetStoredMnemonicResponse {
  string mnemonic = 1;
}

message RestoreKeyPairViaMnemonicRequest {
  string mnemonic = 1;
}

message RestoreKeyPairViaMnemonicResponse {}

enum EventType {
  ENTRY_ADDED = 0;
  ENTRY_DELETED = 1;
  ENTRY_UPDATED = 2;
  ENTRY_BACKUP_IN_PROGRESS = 3;
  ENTRY_BACKUP_READY = 4;
  ENTRY_RESTORE_IN_PROGRESS = 5;
  ENTRY_RESTORE_READY = 6;
  FOLDER_ADDED = 7;
  FOLDER_DELETED = 8;
  FOLDER_UPDATED = 9;
}

message FileEventResponse {
  EventType type = 1;
  ListDirectoryEntry entry = 2;
  string bucket = 3;
  string dbId = 4;
}

message TextileEventResponse {
  string bucket = 1;
}

message OpenFileRequest {
  string path = 1;
  string bucket = 2;
  string dbId = 3; // optional field to specify shared with me file
}

message OpenFileResponse {
  string location = 1;
}

message OpenPublicFileRequest {
  string fileCid = 1;
  string password = 2;
  string filename = 3;
}

message OpenPublicFileResponse {
  string location = 1;
}

message AddItemsRequest {
  // full paths to file or Folder on FS. Needs to be a location available to the daemon
  repeated string sourcePaths = 1;
  // target path in bucket.
  string targetPath = 2;
  // The bucket in which to save the item
  string bucket = 3;
}

message AddItemResult {
  string sourcePath= 1;
  string bucketPath = 2;
  string error = 3;
}

message AddItemsResponse {
  AddItemResult result = 1;
  int64 totalFiles = 2;
  int64 totalBytes = 3;
  int64 completedFiles = 4;
  int64 completedBytes = 5;
}

message CreateFolderRequest {
  // target path in bucket to add new empty folder
  string path = 1;
  // The bucket in which to add the folder
  string bucket = 2;
}
// not sure we need to return anything other than an error if we failed
message CreateFolderResponse {
}

enum KeyBackupType {
  PASSWORD = 0;
  GOOGLE = 1;
  TWITTER = 2;
  EMAIL = 3;
}

message BackupKeysByPassphraseRequest {
  string uuid = 1;
  string passphrase = 2;
  KeyBackupType type = 3;
}

message BackupKeysByPassphraseResponse {}

message RecoverKeysByPassphraseRequest {
  string uuid = 1;
  string passphrase = 2;
  KeyBackupType type = 3;
}

message RecoverKeysByPassphraseResponse {}

message TestKeysPassphraseRequest {
  string uuid = 1;
  string passphrase = 2;
}

message TestKeysPassphraseResponse {}

message ThreadInfo {
  repeated string addresses = 1;
  string key = 2;
}

message ShareBucketRequest {
  string bucket = 1;
}

message ShareBucketResponse {
  ThreadInfo threadinfo = 1;
}

message JoinBucketRequest {
  ThreadInfo threadinfo = 1;
  string bucket = 2;
}

message JoinBucketResponse {
  bool result = 1;
}


message ShareFilesViaPublicKeyRequest {
  repeated string publicKeys = 1;
  repeated FullPath paths = 2;
}

message FullPath {
  string dbId = 1; // optional field to specify shared with me file
  string bucket = 2;
  string path = 3;
}

message ShareFilesViaPublicKeyResponse {}

message UnshareFilesViaPublicKeyRequest {
  repeated string publicKeys = 1;
  repeated FullPath paths = 2;
}

message UnshareFilesViaPublicKeyResponse {}

message GeneratePublicFileLinkRequest {
  string bucket = 1;
  repeated string itemPaths = 2;
  string password = 3;
  // optional field to specify db id
  // for shared with me files
  string dbId = 4;
}

message GeneratePublicFileLinkResponse {
  string link = 1;
  string fileCid = 2;
}

message ToggleFuseRequest {
  bool mountDrive = 1;
}

enum FuseState {
  UNSUPPORTED = 0;
  NOT_INSTALLED = 1;
  UNMOUNTED = 2;
  MOUNTED = 3;
}

message FuseDriveResponse {
  FuseState state = 1;
  string mountPath = 2;
}

message ListBucketsRequest {}

message ListBucketsResponse {
  repeated Bucket buckets = 1;
}

enum NotificationType {
  UNKNOWN = 0;
  INVITATION = 1;
  USAGEALERT = 2;
  INVITATION_REPLY = 3;
  REVOKED_INVITATION = 4;
}

enum InvitationStatus {
  PENDING = 0;
  ACCEPTED = 1;
  REJECTED = 2;
}

message Invitation {
  string inviterPublicKey = 1;
  string invitationID = 2;
  InvitationStatus status = 4;
  repeated FullPath itemPaths = 5;
}

message UsageAlert {
  int64 used = 1;
  int64 limit = 2;
  string message = 3;
}

message InvitationAccept {
  string invitationID = 2;
}

message RevokedInvitation {
  string inviterPublicKey = 1;
  repeated FullPath itemPaths = 5;
}

message Notification {
  string ID = 1; // underlying message id from textile
  string subject = 2;
  string body = 3;
  oneof relatedObject {
    Invitation invitationValue = 4;
    UsageAlert usageAlert = 5;
    InvitationAccept invitationAccept = 6;
    RevokedInvitation revokedInvitation = 7;
  }
  NotificationType type = 8;
  int64 createdAt = 9;
  int64 readAt = 10;
}

message HandleFilesInvitationRequest {
  string invitationID = 1;
  bool accept = 2;
}

message HandleFilesInvitationResponse {}

message NotificationEventResponse {
  Notification notification = 1;
}

message GetNotificationsRequest {
  string seek = 1;
  int64 limit = 2;
}

message GetNotificationsResponse {
  repeated Notification notifications= 1;
  string nextOffset = 2;
  int64 lastSeenAt = 3;
}
message ReadNotificationRequest {
  string ID = 1;
}

message ReadNotificationResponse {
}

message GetPublicKeyRequest {}

message GetPublicKeyResponse {
  // Public key encoded in hex
  string publicKey = 1;
}

message RecoverKeysByLocalBackupRequest {
  string pathToKeyBackup = 1;
}

message RecoverKeysByLocalBackupResponse {}

message CreateLocalKeysBackupRequest {
  // The path in which to save the backup
  string pathToKeyBackup = 1;
}

message CreateLocalKeysBackupResponse {}

message DeleteAccountRequest {}

message DeleteAccountResponse {}

message DeleteKeyPairRequest {}

message DeleteKeyPairResponse {}

message GetAPISessionTokensRequest {}

message GetAPISessionTokensResponse {
  string hubToken = 1;
  string servicesToken = 2;
}

message GetRecentlySharedWithRequest {}

message GetRecentlySharedWithResponse {
 repeated FileMember members = 1;
}

message InitializeMasterAppTokenRequest {}

message InitializeMasterAppTokenResponse {
  string appToken = 1;
}

message AllowedMethod {
  string methodName = 1;
}

message GenerateAppTokenRequest {
  repeated AllowedMethod allowedMethods = 1;
}

message GenerateAppTokenResponse {
  string appToken = 1;
}

message RemoveDirOrFileRequest {
  string path = 1;
  string bucket = 2;
}

message RemoveDirOrFileResponse {}