@dxos/plugin-space 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

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.'));

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

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+
+type SchemaEntry = {
+  id?: string;
+  typename: string;
+  version: string;
+};
+
+export const mapSchemas = (schemas: SchemaEntry[]) => {
+  return schemas.map((schema) => ({
+    id: schema.id,
+    typename: schema.typename,
+    version: schema.version,
+  }));
+};
+
+export const printSchema = (schema: SchemaEntry) =>
+  FormBuilder.make({ title: schema.typename }).pipe(
+    FormBuilder.set('id', schema.id ?? '<none>'),
+    FormBuilder.set('typename', schema.typename),
+    FormBuilder.set('version', schema.version),
+    FormBuilder.build,
+  );
+
+export const printSchemas = (schemas: SchemaEntry[]) => {
+  return schemas.map(printSchema);
+};
+
+export const createTypenameFilter = (typenameFilter?: string) => {
+  if (!typenameFilter) {
+    return () => true;
+  }
+
+  return (schema: SchemaEntry) => schema.typename.toLowerCase().includes(typenameFilter.toLowerCase());
+};

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

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

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

@@ -0,0 +1,112 @@
+//
+// 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,
+  copyToClipboard,
+  getSpace,
+  openBrowser,
+  print,
+  spaceIdWithDefault,
+} from '@dxos/cli-util';
+import { FormBuilder } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { Invitation, InvitationEncoder, hostInvitation } from '@dxos/client/invitations';
+import { type Key } from '@dxos/echo';
+
+export const handler = Effect.fn(function* ({
+  spaceId,
+  multiple,
+  open,
+  host,
+}: {
+  spaceId: Option.Option<string>;
+  multiple: boolean;
+  open: boolean;
+  host: string;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId as Option.Option<Key.SpaceId>);
+  const space = yield* getSpace(resolvedSpaceId);
+
+  // Always use persistent and delegated (auth required) due to P2P limitations
+  const observable = space.share({
+    authMethod: Invitation.AuthMethod.SHARED_SECRET,
+    persistent: true,
+    multiUse: multiple,
+  });
+
+  const invitation = yield* hostInvitation({
+    observable,
+    callbacks: {
+      onConnecting: (invitation) =>
+        Effect.gen(function* () {
+          const invitationCode = InvitationEncoder.encode(invitation);
+          const authCode = invitation.authCode!;
+
+          // Copy auth code to clipboard
+          yield* copyToClipboard(authCode).pipe(Effect.catchAll(() => Effect.void));
+
+          if (!json) {
+            yield* Console.log(`\nSecret: ${authCode} (copied to clipboard)\n`);
+          }
+
+          if (open) {
+            const url = new URL(host);
+            url.searchParams.append('spaceInvitationCode', invitationCode);
+            yield* openBrowser(url.toString()).pipe(Effect.catchAll(() => Effect.void));
+          } else if (!json) {
+            yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+          }
+        }),
+    },
+    waitForSuccess: true,
+  });
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          invitationCode: InvitationEncoder.encode(invitation),
+          authCode: invitation.authCode,
+          state: Invitation.State[invitation.state],
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    const builder = FormBuilder.make({ title: 'Space Invitation' }).pipe(
+      FormBuilder.set('invitationCode', InvitationEncoder.encode(invitation)),
+      FormBuilder.set('authCode', invitation.authCode ?? '<none>'),
+      FormBuilder.set('state', Invitation.State[invitation.state]),
+    );
+    yield* Console.log(print(FormBuilder.build(builder)));
+  }
+});
+
+export const share = Command.make(
+  'share',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    multiple: Options.boolean('multiple', { ifPresent: true }).pipe(
+      Options.withDescription('Create a multi-use invitation.'),
+    ),
+    open: Options.boolean('open', { ifPresent: true }).pipe(Options.withDescription('Open browser with invitation.')),
+    host: Options.text('host').pipe(
+      Options.withDescription('Application Host URL.'),
+      Options.withDefault('https://composer.space'),
+    ),
+  },
+  handler,
+).pipe(Command.withDescription('Create space invitation.'));

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

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

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

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+
+describe('spaces sync', () => {
+  // TODO(wittjosiah): Need to create a mock edge to sync with.
+  it.todo('should sync a synced space');
+  it.todo('should sync an unsynced space');
+  it.todo('should sync a missing space');
+});

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

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+
+import { Common, getSpace, spaceIdWithDefault, waitForSync, withTimeout } from '@dxos/cli-util';
+
+export const sync = Command.make(
+  'sync',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    spaceTimeout: Options.integer('spaceTimeout').pipe(
+      Options.withDescription('The timeout to wait for the space to be available in milliseconds.'),
+      Options.withDefault(5000),
+    ),
+  },
+  ({ spaceId, spaceTimeout }) =>
+    Effect.gen(function* () {
+      // If space is not available locally, wait for it to sync.
+      const resolvedSpaceId = yield* spaceIdWithDefault(spaceId);
+      const space = yield* getSpace(resolvedSpaceId).pipe(
+        Effect.retry(Schedule.fixed('100 millis')),
+        Effect.timeout(Duration.millis(spaceTimeout)),
+      );
+
+      yield* waitForSync(space);
+    }).pipe(withTimeout),
+).pipe(Command.withDescription('Wait for a space to be fully synchronized with EDGE.'));

package/src/cli/index.ts

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

package/src/cli/plugin.ts

@@ -0,0 +1,99 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { Tag } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { ClientEvents } from '@dxos/plugin-client/types';
+import { DataTypes } from '@dxos/schema';
+import {
+  AnchoredTo,
+  Employer,
+  Event,
+  HasConnection,
+  HasRelationship,
+  HasSubject,
+  Organization,
+  Person,
+  Pipeline,
+  Task,
+} from '@dxos/types';
+
+import { IdentityCreated, OperationHandler, UndoMappings } from '#capabilities';
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+import { SpaceEvents } from '#types';
+import { type CreateObject, type SpacePluginOptions } from '#types';
+
+import { database, queue, space } from './commands';
+
+export const SpacePlugin = Plugin.define<SpacePluginOptions>(meta).pipe(
+  // TODO(wittjosiah): Could some of these commands make use of operations?
+  AppPlugin.addCommandModule({
+    commands: [database, queue, space],
+  }),
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Collection.Collection.typename,
+      metadata: {
+        createObject: ((props, options) =>
+          Effect.gen(function* () {
+            const object = Collection.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          })) satisfies CreateObject,
+      },
+    },
+  }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      ...DataTypes,
+      AnchoredTo.AnchoredTo,
+      Employer.Employer,
+      Event.Event,
+      HasConnection.HasConnection,
+      HasRelationship.HasRelationship,
+      HasSubject.HasSubject,
+      Organization.Organization,
+      Person.Person,
+      Pipeline.Pipeline,
+      Tag.Tag,
+      Task.Task,
+    ],
+  }),
+  Plugin.addModule(
+    ({
+      shareableLinkOrigin = 'http://localhost:5173',
+      invitationPath = '/',
+      invitationProp = 'spaceInvitationCode',
+    }) => {
+      const createInvitationUrl = (invitationCode: string) => {
+        const baseUrl = new URL(invitationPath || '/', shareableLinkOrigin);
+        baseUrl.searchParams.set(invitationProp, invitationCode);
+        return baseUrl.toString();
+      };
+
+      return {
+        id: Capability.getModuleTag(UndoMappings),
+        activatesOn: ActivationEvents.SetupOperationHandler,
+        activate: () => UndoMappings({ createInvitationUrl, observability: false }),
+      };
+    },
+  ),
+  Plugin.addModule({
+    activatesOn: ClientEvents.IdentityCreated,
+    firesAfterActivation: [SpaceEvents.PersonalSpaceReady],
+    activate: IdentityCreated,
+  }),
+  Plugin.make,
+);

package/src/components/AwaitingObject/AwaitingObject.tsx

@@ -0,0 +1,114 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { useLayout } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { useClient } from '@dxos/react-client';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { Button, Icon, Toast, useTranslation } from '@dxos/react-ui';
+import { osTranslations } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+
+const WAIT_FOR_OBJECT_TIMEOUT = 3 * 60 * 1_000;
+const TOAST_TIMEOUT = 4 * 60 * 1_000;
+
+export const AwaitingObject = ({ id }: { id: string }) => {
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
+  const [open, setOpen] = useState(true);
+  const [waiting, setWaiting] = useState(true);
+  const [found, setFound] = useState(false);
+  const layout = useLayout();
+
+  const client = useClient();
+  const objects = useQuery(client.spaces, Filter.everything());
+
+  useEffect(() => {
+    if (!id) {
+      return;
+    }
+
+    const timeout = setTimeout(() => setWaiting(false), WAIT_FOR_OBJECT_TIMEOUT);
+    return () => clearTimeout(timeout);
+  }, [id]);
+
+  useEffect(() => {
+    if (objects.findIndex((object) => Obj.getDXN(object).toString() === id) > -1) {
+      setFound(true);
+      if (layout.active.includes(id)) {
+        setOpen(false);
+      }
+    }
+  }, [id, objects, layout]);
+
+  const handleClose = useCallback(
+    async () => invokePromise(SpaceOperation.WaitForObject, { id: undefined }),
+    [invokePromise],
+  );
+
+  const handleNavigate = useCallback(() => {
+    void invokePromise(LayoutOperation.Open, { subject: [id] });
+    void handleClose();
+  }, [id, handleClose, invokePromise]);
+
+  return (
+    <Toast.Root open={open} duration={TOAST_TIMEOUT} onOpenChange={setOpen}>
+      <Toast.Body>
+        <Toast.Title classNames='flex items-center gap-2'>
+          {found ? (
+            <>
+              <Icon icon='ph--check-circle--regular' />
+              <span>{t('found-object.label')}</span>
+            </>
+          ) : waiting ? (
+            <>
+              <Icon icon='ph--circle-notch--regular' classNames='animate-spin' />
+              <span>{t('waiting-for-object.label')}</span>
+            </>
+          ) : (
+            <>
+              <Icon icon='ph--circle-dashed--regular' />
+              <span>{t('object-not-found.label')}</span>
+            </>
+          )}
+        </Toast.Title>
+        <Toast.Description>
+          {t(
+            found
+              ? 'found-object.description'
+              : waiting
+                ? 'waiting-for-object.description'
+                : 'object-not-found.description',
+          )}
+        </Toast.Description>
+      </Toast.Body>
+      <Toast.Actions>
+        {found ? (
+          <>
+            <Toast.Action altText={t('go-to-object.alt')} asChild>
+              <Button variant='primary' onClick={handleNavigate}>
+                {t('go-to-object.label')}
+              </Button>
+            </Toast.Action>
+            <Toast.Close asChild>
+              <Button onClick={handleClose}>{t('close.label', { ns: osTranslations })}</Button>
+            </Toast.Close>
+          </>
+        ) : (
+          <Toast.Close asChild>
+            <Button onClick={handleClose}>
+              {t(waiting ? 'close.label' : 'confirm.label', { ns: osTranslations })}
+            </Button>
+          </Toast.Close>
+        )}
+      </Toast.Actions>
+    </Toast.Root>
+  );
+};

package/src/components/AwaitingObject/index.ts

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