@dxos/protocols 0.8.1-main.ba2dec9 → 0.8.1-staging.31c3ee1

package/src/edge-error.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EdgeErrorData, type EdgeHttpFailure } from './edge';
+
+export class EdgeCallFailedError extends Error {
+  public static fromProcessingFailureCause(cause: Error) {
+    return new EdgeCallFailedError({
+      reason: 'Error processing request.',
+      isRetryable: true,
+      cause,
+    });
+  }
+
+  public static fromHttpFailure(response: Response) {
+    return new EdgeCallFailedError({
+      reason: `HTTP code ${response.status}: ${response.statusText}.`,
+      isRetryable: isRetryableCode(response.status),
+      retryAfterMs: getRetryAfterMillis(response),
+    });
+  }
+
+  public static fromUnsuccessfulResponse(response: Response, body: EdgeHttpFailure) {
+    return new EdgeCallFailedError({
+      reason: body.reason,
+      errorData: body.errorData,
+      isRetryable: body.errorData == null && response.headers.has('Retry-After'),
+      retryAfterMs: getRetryAfterMillis(response),
+    });
+  }
+
+  readonly reason: string;
+  readonly errorData?: EdgeErrorData;
+  readonly isRetryable?: boolean;
+  readonly retryAfterMs?: number;
+
+  constructor(args: {
+    reason: string;
+    isRetryable?: boolean;
+    errorData?: EdgeErrorData;
+    retryAfterMs?: number;
+    cause?: Error;
+  }) {
+    super(args.reason, { cause: args.cause });
+    this.reason = args.reason;
+    this.errorData = args.errorData;
+    this.retryAfterMs = args.retryAfterMs;
+    this.isRetryable = Boolean(args.isRetryable);
+  }
+}
+
+export class EdgeAuthChallengeError extends EdgeCallFailedError {
+  constructor(
+    public readonly challenge: string,
+    errorData: EdgeErrorData,
+  ) {
+    super({ reason: 'Auth challenge.', errorData, isRetryable: false });
+  }
+}
+
+const getRetryAfterMillis = (response: Response) => {
+  const retryAfter = Number(response.headers.get('Retry-After'));
+  return Number.isNaN(retryAfter) || retryAfter === 0 ? undefined : retryAfter * 1000;
+};
+
+export const createRetryableHttpFailure = (args: { reason: any; retryAfterSeconds: number }) => {
+  return new Response(JSON.stringify({ success: false, reason: args.reason }), {
+    headers: { 'Retry-After': String(args.retryAfterSeconds) },
+  });
+};
+
+const isRetryableCode = (status: number) => {
+  if (status === 501) {
+    // Not Implemented
+    return false;
+  }
+  return !(status >= 400 && status < 500);
+};

package/src/edge.ts

@@ -2,7 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type SpaceId } from '@dxos/keys';
+import { Schema as S } from 'effect';
+
+import { SpaceId } from '@dxos/keys';
 
 // TODO(burdon): Rename EdgerRouterEndpoint?
 export enum EdgeService {
@@ -83,6 +85,7 @@ export type RecoverIdentityRequest = {
   controlFeedKey: string;
   lookupKey?: string;
   signature?: RecoverIdentitySignature;
+  token?: string;
 };
 
 export type RecoverIdentityResponseBody = {
@@ -132,87 +135,43 @@ export type UploadFunctionResponseBody = {
   };
 };
 
+export type CreateSpaceRequest = {
+  agentKey: string;
+};
+
+export type CreateSpaceResponseBody = {
+  spaceKey: string;
+  spaceId: string;
+  automergeRoot: string;
+};
+
 export enum EdgeAgentStatus {
   ACTIVE = 'active',
   INACTIVE = 'inactive',
   NOT_FOUND = 'not_found',
 }
 
-export class EdgeCallFailedError extends Error {
-  public static fromProcessingFailureCause(cause: Error) {
-    return new EdgeCallFailedError({
-      reason: 'Error processing request.',
-      isRetryable: true,
-      cause,
-    });
-  }
-
-  public static fromHttpFailure(response: Response) {
-    return new EdgeCallFailedError({
-      reason: `HTTP code ${response.status}: ${response.statusText}.`,
-      isRetryable: isRetryableCode(response.status),
-      retryAfterMs: getRetryAfterMillis(response),
-    });
-  }
-
-  public static fromUnsuccessfulResponse(response: Response, body: EdgeHttpFailure) {
-    return new EdgeCallFailedError({
-      reason: body.reason,
-      errorData: body.errorData,
-      isRetryable: body.errorData == null && response.headers.has('Retry-After'),
-      retryAfterMs: getRetryAfterMillis(response),
-    });
-  }
-
-  readonly reason: string;
-  readonly errorData?: EdgeErrorData;
-  readonly isRetryable?: boolean;
-  readonly retryAfterMs?: number;
-
-  constructor(args: {
-    reason: string;
-    isRetryable?: boolean;
-    errorData?: EdgeErrorData;
-    retryAfterMs?: number;
-    cause?: Error;
-  }) {
-    super(args.reason, { cause: args.cause });
-    this.reason = args.reason;
-    this.errorData = args.errorData;
-    this.retryAfterMs = args.retryAfterMs;
-    this.isRetryable = Boolean(args.isRetryable);
-  }
-}
-
-export class EdgeAuthChallengeError extends EdgeCallFailedError {
-  constructor(
-    public readonly challenge: string,
-    errorData: EdgeErrorData,
-  ) {
-    super({ reason: 'Auth challenge.', errorData, isRetryable: false });
-  }
-}
-
 export type EdgeAuthChallenge = {
   type: 'auth_challenge';
   challenge: string;
 };
 
-const getRetryAfterMillis = (response: Response) => {
-  const retryAfter = Number(response.headers.get('Retry-After'));
-  return Number.isNaN(retryAfter) || retryAfter === 0 ? undefined : retryAfter * 1000;
-};
+export enum OAuthProvider {
+  GOOGLE = 'google',
+}
 
-export const createRetryableHttpFailure = (args: { reason: any; retryAfterSeconds: number }) => {
-  return new Response(JSON.stringify({ success: false, reason: args.reason }), {
-    headers: { 'Retry-After': String(args.retryAfterSeconds) },
-  });
-};
+export const InitiateOAuthFlowRequestSchema = S.Struct({
+  provider: S.Enums(OAuthProvider),
+  spaceId: S.String.pipe(S.filter(SpaceId.isValid)),
+  accessTokenId: S.String,
+  scopes: S.mutable(S.Array(S.String)),
+});
+export type InitiateOAuthFlowRequest = S.Schema.Type<typeof InitiateOAuthFlowRequestSchema>;
 
-const isRetryableCode = (status: number) => {
-  if (status === 501) {
-    // Not Implemented
-    return false;
-  }
-  return !(status >= 400 && status < 500);
+export type InitiateOAuthFlowResponse = {
+  authUrl: string;
 };
+
+export type OAuthFlowResult =
+  | { success: true; accessToken: string; accessTokenId: string }
+  | { success: false; reason: string };

package/src/index.ts

@@ -12,3 +12,5 @@ export * from './profile-archive.js';
 export * from './automerge.js';
 export * from './edge.js';
 export * from './queue.js';
+export * from './space-archive.js';
+export * from './edge-error.js';

package/src/proto/dxos/client/services.proto

@@ -144,6 +144,7 @@ message RecoverIdentityRequest {
   oneof request {
     string recovery_code = 1;
     ExternalSignature external = 2;
+    string token = 3;
   }
 }
 
@@ -433,6 +434,28 @@ message JoinBySpaceKeyRequest {
   dxos.keys.PublicKey space_key = 1;
 }
 
+message SpaceArchive {
+  string filename = 1;
+  bytes contents = 2;
+}
+
+message ExportSpaceRequest {
+  string space_id = 1;
+}
+
+message ExportSpaceResponse {
+  SpaceArchive archive = 1;
+}
+
+message ImportSpaceRequest {
+  SpaceArchive archive = 1;
+}
+
+message ImportSpaceResponse {
+  /// the ID of the new space.
+  string new_space_id = 1;
+}
+
 service SpacesService {
   rpc CreateSpace(google.protobuf.Empty) returns (Space);
   rpc UpdateSpace(UpdateSpaceRequest) returns (google.protobuf.Empty);
@@ -454,6 +477,9 @@ service SpacesService {
   rpc QueryCredentials(QueryCredentialsRequest) returns (stream dxos.halo.credentials.Credential);
 
   rpc CreateEpoch(CreateEpochRequest) returns (CreateEpochResponse);
+
+  rpc ExportSpace(ExportSpaceRequest) returns (ExportSpaceResponse);
+  rpc ImportSpace(ImportSpaceRequest) returns (ImportSpaceResponse);
 }
 
 //

package/src/proto/dxos/edge/calls.proto

@@ -4,6 +4,8 @@
 
 syntax = "proto3";
 
+import "google/protobuf/any.proto";
+
 import "dxos/keys.proto";
 
 package dxos.edge.calls;
@@ -25,22 +27,27 @@ message UserState {
   bool speaking = 5;
   bool joined = 6;
   Tracks tracks = 7;
-  optional Transcription transcription = 8;
+  map<string, Activity> activities = 8;
 }
 
 /**
- * Transcription settings.
+ * Activity state.
  * It will be merged across all users in the room based on the Lamport timestamp (last one wins).
  */
-message Transcription {
-  bool enabled = 1;
+message Activity {
+  LamportTimestamp lamport_timestamp = 1;
 
-  LamportTimestamp lamport_timestamp = 2;
+  google.protobuf.Any payload = 10;
+}
 
-  /**
-   * Transcription queue DXN.
-   */
-  string queue_dxn = 3;
+/**
+ * Transcription state.
+ *
+ * Used to encode/decode the Any payload of a call activity for the transcription plugin.
+ */
+ message TranscriptionPayload {
+  bool enabled = 1;
+  string queue_dxn = 2;
 }
 
 /**

package/src/proto/gen/dxos/client/services.ts

@@ -622,6 +622,7 @@ export interface RequestRecoveryChallengeResponse {
 export interface RecoverIdentityRequest {
     recoveryCode?: string;
     external?: RecoverIdentityRequest.ExternalSignature;
+    token?: string;
 }
 export namespace RecoverIdentityRequest {
     /**
@@ -1170,6 +1171,45 @@ export interface JoinSpaceResponse {
 export interface JoinBySpaceKeyRequest {
     spaceKey: ReturnType<(typeof substitutions)["dxos.keys.PublicKey"]["decode"]>;
 }
+/**
+ * Defined in:
+ *   {@link file://./../../../dxos/client/services.proto}
+ */
+export interface SpaceArchive {
+    filename: string;
+    contents: Uint8Array;
+}
+/**
+ * Defined in:
+ *   {@link file://./../../../dxos/client/services.proto}
+ */
+export interface ExportSpaceRequest {
+    spaceId: string;
+}
+/**
+ * Defined in:
+ *   {@link file://./../../../dxos/client/services.proto}
+ */
+export interface ExportSpaceResponse {
+    archive: SpaceArchive;
+}
+/**
+ * Defined in:
+ *   {@link file://./../../../dxos/client/services.proto}
+ */
+export interface ImportSpaceRequest {
+    archive: SpaceArchive;
+}
+/**
+ * Defined in:
+ *   {@link file://./../../../dxos/client/services.proto}
+ */
+export interface ImportSpaceResponse {
+    /**
+     * the ID of the new space.
+     */
+    newSpaceId: string;
+}
 /**
  * Defined in:
  *   {@link file://./../../../dxos/client/services.proto}
@@ -1198,6 +1238,8 @@ export interface SpacesService {
      */
     queryCredentials: (request: QueryCredentialsRequest, options?: RequestOptions) => Stream<dxos_halo_credentials.Credential>;
     createEpoch: (request: CreateEpochRequest, options?: RequestOptions) => Promise<CreateEpochResponse>;
+    exportSpace: (request: ExportSpaceRequest, options?: RequestOptions) => Promise<ExportSpaceResponse>;
+    importSpace: (request: ImportSpaceRequest, options?: RequestOptions) => Promise<ImportSpaceResponse>;
 }
 /**
  * Defined in:

package/src/proto/gen/dxos/edge/calls.ts

@@ -117,25 +117,29 @@ export interface UserState {
     speaking: boolean;
     joined: boolean;
     tracks: Tracks;
-    /**
-     * Options:
-     *   - proto3_optional = true
-     */
-    transcription?: Transcription;
+    activities?: Partial<Record<string, Activity>>;
 }
 /**
- * Transcription settings.
+ * Activity state.
  * It will be merged across all users in the room based on the Lamport timestamp (last one wins).
  *
  * Defined in:
  *   {@link file://./../../../dxos/edge/calls.proto}
  */
-export interface Transcription {
-    enabled: boolean;
+export interface Activity {
     lamportTimestamp: LamportTimestamp;
-    /**
-     * Transcription queue DXN.
-     */
+    payload: ReturnType<(typeof substitutions)["google.protobuf.Any"]["decode"]>;
+}
+/**
+ * Transcription state.
+ *
+ * Used to encode/decode the Any payload of a call activity for the transcription plugin.
+ *
+ * Defined in:
+ *   {@link file://./../../../dxos/edge/calls.proto}
+ */
+export interface TranscriptionPayload {
+    enabled: boolean;
     queueDxn: string;
 }
 /**