@dxos/plugin-space 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

package/src/{components/SpacePresence → cli/commands/space/create}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './SpacePresence';
+export * from './create';

package/src/cli/commands/space/index.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { close } from './close';
+import { create } from './create';
+import { info } from './info';
+import { join } from './join';
+import { list } from './list';
+import { members } from './members';
+import { open } from './open';
+import { schema } from './schema';
+import { share } from './share';
+import { sync } from './sync';
+
+export const space = Command.make('space').pipe(
+  Command.withDescription('Manage ECHO spaces.'),
+  Command.withSubcommands([close, create, info, join, list, members, open, schema, share, sync]),
+);

package/src/cli/commands/space/info/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './info';

package/src/cli/commands/space/info/info.test.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './info';
+
+describe('space info', () => {
+  it('should show space info', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      yield* handler({ spaceId: Option.some(space.id) });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson<{ id: string; state: string; key: string }>(logs[0]);
+      expect(parsed).toHaveProperty('id');
+      expect(parsed).toHaveProperty('state');
+      expect(parsed).toHaveProperty('key');
+      expect(parsed.id).toBe(space.id);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/space/info/info.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import type * as Option from 'effect/Option';
+
+import { CommandConfig, Common, formatSpace, getSpace, print, printSpace, spaceIdWithDefault } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Key } from '@dxos/echo';
+
+export const handler = Effect.fn(function* ({ spaceId }: { spaceId: Option.Option<string> }) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId as Option.Option<Key.SpaceId>);
+  const space = yield* getSpace(resolvedSpaceId);
+
+  const formatted = yield* formatSpace(space);
+
+  if (json) {
+    yield* Console.log(JSON.stringify(formatted, null, 2));
+  } else {
+    yield* Console.log(print(printSpace(formatted)));
+  }
+});
+
+export const info = Command.make(
+  'info',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+  },
+  handler,
+).pipe(Command.withDescription('Show space info.'));

package/src/cli/commands/space/join/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './join';

package/src/cli/commands/space/join/join.ts

@@ -0,0 +1,122 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Args from '@effect/cli/Args';
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Prompt from '@effect/cli/Prompt';
+import * as Console from 'effect/Console';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { print, waitForSync } from '@dxos/cli-util';
+import { FormBuilder } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+
+import { acceptInvitation } from './util';
+
+export const handler = Effect.fn(function* ({
+  invitationCode,
+  authCode,
+}: {
+  invitationCode: string;
+  authCode: Option.Option<string>;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  let encoded = invitationCode;
+  if (encoded.startsWith('http') || encoded.startsWith('socket')) {
+    const searchProps = new URL(encoded).searchParams;
+    encoded = searchProps.get('spaceInvitationCode') ?? encoded;
+  }
+
+  const invitation = yield* acceptInvitation({
+    observable: client.spaces.join(encoded),
+    callbacks: {
+      onReadyForAuth: (invitation) => {
+        if (Option.isSome(authCode)) {
+          return Effect.succeed(Option.getOrUndefined(authCode) ?? undefined) as Effect.Effect<
+            string | void,
+            never,
+            never
+          >;
+        }
+        return Prompt.text({ message: 'Enter the authentication code' })
+          .pipe(Prompt.run)
+          .pipe(Effect.mapError(() => undefined as never))
+          .pipe(Effect.catchAll(() => Effect.succeed(undefined))) as Effect.Effect<string | void, never, never>;
+      },
+    },
+  });
+
+  // Wait for space to be available with retry logic
+  const spaceKey = invitation.spaceKey;
+  if (!spaceKey) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'No space key in invitation' }, null, 2));
+    } else {
+      yield* Console.log('No space key in invitation.');
+    }
+    return;
+  }
+
+  let space = client.spaces.get(spaceKey);
+  if (!space) {
+    // Retry up to 5 times with increasing delays
+    const maxRetries = 5;
+    const retryDelays = [0.5, 1, 1.5, 2, 2.5].map((s) => Duration.seconds(s));
+    for (let i = 0; i < maxRetries; i++) {
+      yield* Effect.sleep(retryDelays[i]);
+      space = client.spaces.get(spaceKey);
+      if (space) {
+        break;
+      }
+    }
+  }
+
+  if (!space) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'Space not found after joining' }, null, 2));
+    } else {
+      yield* Console.log('Space not found after joining.');
+    }
+    return;
+  }
+
+  // Flush and sync after joining
+  yield* Effect.tryPromise(() => space.db.flush());
+  yield* waitForSync(space);
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          spaceId: space.id,
+          state: space.state.get(),
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    const builder = FormBuilder.make({ title: 'Joined Space' }).pipe(
+      FormBuilder.set('spaceId', space.id),
+      FormBuilder.set('key', space.key.truncate()),
+      FormBuilder.set('name', space.properties.name ?? '<none>'),
+    );
+    yield* Console.log(print(FormBuilder.build(builder)));
+  }
+});
+
+export const join = Command.make(
+  'join',
+  {
+    invitationCode: Args.text({ name: 'invitationCode' }).pipe(Args.withDescription('The invitation code.')),
+    authCode: Options.text('authCode').pipe(Options.withDescription('The authentication code.'), Options.optional),
+  },
+  handler,
+).pipe(Command.withDescription('Join a space via invitation.'));

package/src/cli/commands/space/join/util.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Queue from 'effect/Queue';
+
+import { type AuthenticatingInvitationObservable, Invitation } from '@dxos/client/invitations';
+import { runAndForwardErrors } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { AlreadyJoinedError } from '@dxos/protocols';
+
+type AcceptInvitationProps = {
+  observable: AuthenticatingInvitationObservable;
+  callbacks?: {
+    onConnecting?: (invitation: Invitation) => Effect.Effect<void>;
+    onReadyForAuth?: (invitation: Invitation) => Effect.Effect<string | void, never, never>;
+    onSuccess?: (invitation: Invitation) => Effect.Effect<void>;
+  };
+};
+
+/**
+ * Accept an invitation and handle authentication flow.
+ * Ported from cli-base to Effect-based approach.
+ */
+export const acceptInvitation = ({ observable, callbacks }: AcceptInvitationProps): Effect.Effect<Invitation, Error> =>
+  Effect.gen(function* () {
+    const doneQueue = yield* Queue.unbounded<Invitation>();
+
+    const runCallback = (effect: Effect.Effect<void> | undefined) => {
+      if (effect) {
+        runAndForwardErrors(effect).catch(() => {
+          // Ignore callback errors
+        });
+      }
+    };
+
+    const subscription = observable.subscribe(
+      (invitation) => {
+        switch (invitation.state) {
+          case Invitation.State.CONNECTING: {
+            runCallback(callbacks?.onConnecting?.(invitation));
+            break;
+          }
+
+          case Invitation.State.READY_FOR_AUTHENTICATION: {
+            if (invitation.authMethod === Invitation.AuthMethod.SHARED_SECRET) {
+              const callbackEffect = callbacks?.onReadyForAuth?.(invitation) ?? Effect.succeed(undefined);
+              Effect.gen(function* () {
+                const callbackResult = yield* callbackEffect;
+                const code = invitation.authCode ?? callbackResult;
+                invariant(code, 'No code provided');
+                yield* Effect.tryPromise(() => observable.authenticate(code));
+              })
+                .pipe(runAndForwardErrors)
+                .catch(() => {
+                  // Error handling
+                });
+            }
+            break;
+          }
+
+          case Invitation.State.SUCCESS: {
+            runCallback(callbacks?.onSuccess?.(invitation));
+            runAndForwardErrors(Queue.offer(doneQueue, invitation)).catch(() => {});
+            break;
+          }
+        }
+      },
+      (err) => {
+        if (err instanceof AlreadyJoinedError) {
+          runAndForwardErrors(Queue.offer(doneQueue, observable.get())).catch(() => {});
+          return;
+        }
+        throw err;
+      },
+    );
+
+    const invitation = yield* Queue.take(doneQueue);
+    subscription.unsubscribe();
+    return invitation;
+  });

package/src/cli/commands/space/list/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './list';

package/src/cli/commands/space/list/list.test.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './list';
+
+describe('spaces list', () => {
+  it('should list empty space list', () =>
+    Effect.gen(function* () {
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      expect(TestConsole.extractJsonString(logs[0])).toEqual('[]');
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+
+  it('should list spaces', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      yield* Effect.tryPromise(() => client.spaces.create());
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const formattedSpaces = TestConsole.parseJson(logs[0]);
+      expect(formattedSpaces).toHaveLength(2);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/space/list/list.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, formatSpace, printSpace } from '@dxos/cli-util';
+import { printList } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+
+// TODO(burdon): Move handler inline and test separate functions.
+export const handler = Effect.fn(function* () {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  const spaces = client.spaces.get();
+  const formattedSpaces = yield* Effect.all(spaces.map(formatSpace));
+
+  if (json) {
+    yield* Console.log(JSON.stringify(formattedSpaces, null, 2));
+  } else {
+    const formatted = formattedSpaces.map(printSpace);
+    yield* Console.log(printList(formatted));
+  }
+});
+
+export const list = Command.make('list', {}, handler).pipe(
+  Command.withDescription('List all spaces available on this device.'),
+);

package/src/cli/commands/space/members/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './members';

package/src/cli/commands/space/members/members.test.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './members';
+
+describe('space members', () => {
+  it('should list space members', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      yield* handler({ spaceId: Option.some(space.id) });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson<Array<{ key: string; presence: string }>>(logs[0]);
+      expect(Array.isArray(parsed)).toBe(true);
+      expect(parsed.length).toBeGreaterThan(0);
+      expect(parsed[0]).toHaveProperty('key');
+      expect(parsed[0]).toHaveProperty('presence');
+      // name might be undefined if identity has no displayName
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/space/members/members.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import type * as Option from 'effect/Option';
+
+import { CommandConfig, Common, getSpace, printList, spaceIdWithDefault } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Key } from '@dxos/echo';
+
+import { mapMembers, printMembers } from './util';
+
+export const handler = Effect.fn(function* ({ spaceId }: { spaceId: Option.Option<string> }) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId as Option.Option<Key.SpaceId>);
+  const space = yield* getSpace(resolvedSpaceId);
+
+  const members = space.members.get();
+
+  if (json) {
+    yield* Console.log(JSON.stringify(mapMembers(members), null, 2));
+  } else {
+    const formatted = printMembers(members);
+    yield* Console.log(printList(formatted));
+  }
+});
+
+export const members = Command.make(
+  'members',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+  },
+  handler,
+).pipe(Command.withDescription('List space members.'));

package/src/cli/commands/space/members/util.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+import { SpaceMember } from '@dxos/client/echo';
+
+const maybeTruncateKey = (key: { toHex(): string; truncate(): string }, truncate = false) =>
+  truncate ? key.truncate() : key.toHex();
+
+export const mapMembers = (members: SpaceMember[], truncateKeys = false) => {
+  return members.map((member) => ({
+    key: maybeTruncateKey(member.identity.identityKey, truncateKeys),
+    name: member.identity.profile?.displayName,
+    presence: member.presence === SpaceMember.PresenceState.ONLINE ? 'Online' : 'Offline',
+  }));
+};
+
+export const printMember = (member: SpaceMember) =>
+  FormBuilder.make({ title: member.identity.profile?.displayName ?? member.identity.identityKey.truncate() }).pipe(
+    FormBuilder.set('identityKey', member.identity.identityKey.truncate()),
+    FormBuilder.set('displayName', member.identity.profile?.displayName ?? '<none>'),
+    FormBuilder.set('presence', member.presence === SpaceMember.PresenceState.ONLINE ? 'Online' : 'Offline'),
+    FormBuilder.build,
+  );
+
+export const printMembers = (members: SpaceMember[]) => {
+  return members.map(printMember);
+};

package/src/cli/commands/space/open/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './open';

package/src/cli/commands/space/open/open.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, Common, getSpace, waitForSync } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Key } from '@dxos/echo';
+
+export const handler = ({ spaceId }: { spaceId: Key.SpaceId }) =>
+  Effect.gen(function* () {
+    const { json } = yield* CommandConfig;
+    const client = yield* ClientService;
+
+    const space = yield* getSpace(spaceId);
+    yield* Effect.tryPromise(() => space.open());
+
+    // Flush and sync after opening
+    yield* Effect.tryPromise(() => space.db.flush());
+    yield* waitForSync(space);
+
+    if (json) {
+      yield* Console.log(JSON.stringify({ success: true, spaceId }, null, 2));
+    } else {
+      yield* Console.log(`Space ${spaceId} opened successfully.`);
+    }
+  });
+
+export const open = Command.make(
+  'open',
+  {
+    spaceId: Common.spaceId.pipe(Options.withDescription('Space ID to open.')),
+  },
+  handler,
+).pipe(Command.withDescription('Open a space.'));

package/src/cli/commands/space/schema/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { list } from './list';
+
+export const schema = Command.make('schema').pipe(
+  Command.withDescription('Manage space schemas.'),
+  Command.withSubcommands([list]),
+);

package/src/cli/commands/space/schema/list/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './list';

package/src/cli/commands/space/schema/list/list.test.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './list';
+
+describe('space schema list', () => {
+  it('should list space schemas', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      yield* handler({ spaceId: Option.some(space.id), typename: Option.none() });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson(logs[0]);
+      expect(Array.isArray(parsed)).toBe(true);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/space/schema/list/list.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig, Common, getSpace, printList, spaceIdWithDefault } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Key } from '@dxos/echo';
+import { getTypeAnnotation } from '@dxos/echo/internal';
+
+import { createTypenameFilter, mapSchemas, printSchemas } from './util';
+
+export const handler = Effect.fn(function* ({
+  spaceId,
+  typename,
+}: {
+  spaceId: Option.Option<string>;
+  typename: Option.Option<string>;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId as Option.Option<Key.SpaceId>);
+  const space = yield* getSpace(resolvedSpaceId);
+
+  const echoSchema = yield* Effect.tryPromise(() => space.db.schemaRegistry.query().run());
+  const runtimeSchema = space.internal.db.graph.schemaRegistry.schemas;
+
+  const schemas = [
+    ...echoSchema.map((schema) => ({
+      id: schema.id,
+      typename: schema.typename,
+      version: schema.version,
+    })),
+    ...runtimeSchema.map((schema) => {
+      const schemaAnnotation = getTypeAnnotation(schema)!;
+      return {
+        typename: schemaAnnotation.typename,
+        version: schemaAnnotation.version,
+      };
+    }),
+  ].filter(createTypenameFilter(Option.getOrUndefined(typename)));
+
+  if (json) {
+    yield* Console.log(JSON.stringify(mapSchemas(schemas), null, 2));
+  } else {
+    const formatted = printSchemas(schemas);
+    yield* Console.log(printList(formatted));
+  }
+});
+
+export const list = Command.make(
+  'list',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    typename: Options.text('typename').pipe(Options.withDescription('Filter schemas by typename.'), Options.optional),
+  },
+  handler,
+).pipe(Command.withDescription('List space schemas.'));